/**
 * Client
**/

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

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


/**
 * Model Run
 * 
 */
export type Run = $Result.DefaultSelection<Prisma.$RunPayload>
/**
 * Model RunWorkItem
 * 
 */
export type RunWorkItem = $Result.DefaultSelection<Prisma.$RunWorkItemPayload>
/**
 * Model ExecutionInstance
 * 
 */
export type ExecutionInstance = $Result.DefaultSelection<Prisma.$ExecutionInstancePayload>
/**
 * Model RunSlotProjection
 * 
 */
export type RunSlotProjection = $Result.DefaultSelection<Prisma.$RunSlotProjectionPayload>
/**
 * Model TestSuiteRun
 * One execution of a TestTrigger node — orchestrator fans one Run per yielded test-case item.
 * `triggerNodeId` is *not* a foreign key — workflows live in code, not in DB. `triggerNodeName`
 * is snapshotted so historical viewing survives renames/deletions of the trigger node.
 */
export type TestSuiteRun = $Result.DefaultSelection<Prisma.$TestSuiteRunPayload>
/**
 * Model TestAssertion
 * One assertion record persisted by the host-side TestAssertionPersister whenever a node with
 * `emitsAssertions: true` completes inside a test-context run. Each assertion item emitted on
 * `main` becomes one row.
 */
export type TestAssertion = $Result.DefaultSelection<Prisma.$TestAssertionPayload>
/**
 * Model WorkflowDebuggerOverlay
 * 
 */
export type WorkflowDebuggerOverlay = $Result.DefaultSelection<Prisma.$WorkflowDebuggerOverlayPayload>
/**
 * Model WorkflowActivation
 * 
 */
export type WorkflowActivation = $Result.DefaultSelection<Prisma.$WorkflowActivationPayload>
/**
 * Model TriggerSetupState
 * 
 */
export type TriggerSetupState = $Result.DefaultSelection<Prisma.$TriggerSetupStatePayload>
/**
 * Model RunTraceContext
 * 
 */
export type RunTraceContext = $Result.DefaultSelection<Prisma.$RunTraceContextPayload>
/**
 * Model TelemetrySpan
 * 
 */
export type TelemetrySpan = $Result.DefaultSelection<Prisma.$TelemetrySpanPayload>
/**
 * Model WorkflowSnapshot
 * 
 */
export type WorkflowSnapshot = $Result.DefaultSelection<Prisma.$WorkflowSnapshotPayload>
/**
 * Model TelemetryArtifact
 * 
 */
export type TelemetryArtifact = $Result.DefaultSelection<Prisma.$TelemetryArtifactPayload>
/**
 * Model TelemetryMetricPoint
 * 
 */
export type TelemetryMetricPoint = $Result.DefaultSelection<Prisma.$TelemetryMetricPointPayload>
/**
 * Model CredentialInstance
 * 
 */
export type CredentialInstance = $Result.DefaultSelection<Prisma.$CredentialInstancePayload>
/**
 * Model CredentialSecretMaterial
 * 
 */
export type CredentialSecretMaterial = $Result.DefaultSelection<Prisma.$CredentialSecretMaterialPayload>
/**
 * Model CredentialOAuth2Material
 * 
 */
export type CredentialOAuth2Material = $Result.DefaultSelection<Prisma.$CredentialOAuth2MaterialPayload>
/**
 * Model CredentialOAuth2State
 * 
 */
export type CredentialOAuth2State = $Result.DefaultSelection<Prisma.$CredentialOAuth2StatePayload>
/**
 * Model CredentialBinding
 * 
 */
export type CredentialBinding = $Result.DefaultSelection<Prisma.$CredentialBindingPayload>
/**
 * Model CredentialTestResult
 * 
 */
export type CredentialTestResult = $Result.DefaultSelection<Prisma.$CredentialTestResultPayload>
/**
 * Model User
 * Better Auth user directory (DB sessions + optional OAuth linking)
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model UserInvite
 * 
 */
export type UserInvite = $Result.DefaultSelection<Prisma.$UserInvitePayload>
/**
 * Model Account
 * 
 */
export type Account = $Result.DefaultSelection<Prisma.$AccountPayload>
/**
 * Model Session
 * 
 */
export type Session = $Result.DefaultSelection<Prisma.$SessionPayload>
/**
 * Model VerificationToken
 * 
 */
export type VerificationToken = $Result.DefaultSelection<Prisma.$VerificationTokenPayload>
/**
 * Model WorkflowAuditLog
 * 
 */
export type WorkflowAuditLog = $Result.DefaultSelection<Prisma.$WorkflowAuditLogPayload>
/**
 * Model HmacNonce
 * HMAC nonce store for replay protection (T6 security fix).
 * Nonces are persisted across process restarts so a replayed request within
 * the 300-second timestamp window is rejected even after a restart.
 */
export type HmacNonce = $Result.DefaultSelection<Prisma.$HmacNoncePayload>
/**
 * Model HumanTask
 * 
 */
export type HumanTask = $Result.DefaultSelection<Prisma.$HumanTaskPayload>

/**
 * ##  Prisma Client ʲˢ
 *
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient({
 *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
 * })
 * // Fetch zero or more Runs
 * const runs = await prisma.run.findMany()
 * ```
 *
 *
 * Read more in our [docs](https://pris.ly/d/client).
 */
export class PrismaClient<
  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  const U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
> {
  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }

    /**
   * ##  Prisma Client ʲˢ
   *
   * Type-safe database client for TypeScript & Node.js
   * @example
   * ```
   * const prisma = new PrismaClient({
   *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
   * })
   * // Fetch zero or more Runs
   * const runs = await prisma.run.findMany()
   * ```
   *
   *
   * Read more in our [docs](https://pris.ly/d/client).
   */

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

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

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

/**
   * Executes a prepared raw query and returns the number of affected rows.
   * @example
   * ```
   * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
   * ```
   *
   * Read more in our [docs](https://pris.ly/d/raw-queries).
   */
  $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://pris.ly/d/raw-queries).
   */
  $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://pris.ly/d/raw-queries).
   */
  $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://pris.ly/d/raw-queries).
   */
  $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/orm/prisma-client/queries/transactions).
   */
  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * `prisma.humanTask`: Exposes CRUD operations for the **HumanTask** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more HumanTasks
    * const humanTasks = await prisma.humanTask.findMany()
    * ```
    */
  get humanTask(): Prisma.HumanTaskDelegate<ExtArgs, ClientOptions>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

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

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

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

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



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

  export type DecimalJsLike = runtime.DecimalJsLike

  /**
  * 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: 7.5.0
   * Query Engine version: 280c870be64f457428992c43c1f6d557fab6e29e
   */
  export type PrismaVersion = {
    client: string
    engine: string
  }

  export const prismaVersion: PrismaVersion

  /**
   * Utility Types
   */


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

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

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

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

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

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

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

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

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

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

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


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

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

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

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

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

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

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

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

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


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


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

  /**
   * From ts-toolbelt
   */

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

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

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

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

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

  export type Union = any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

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

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


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

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


  export const ModelName: {
    Run: 'Run',
    RunWorkItem: 'RunWorkItem',
    ExecutionInstance: 'ExecutionInstance',
    RunSlotProjection: 'RunSlotProjection',
    TestSuiteRun: 'TestSuiteRun',
    TestAssertion: 'TestAssertion',
    WorkflowDebuggerOverlay: 'WorkflowDebuggerOverlay',
    WorkflowActivation: 'WorkflowActivation',
    TriggerSetupState: 'TriggerSetupState',
    RunTraceContext: 'RunTraceContext',
    TelemetrySpan: 'TelemetrySpan',
    WorkflowSnapshot: 'WorkflowSnapshot',
    TelemetryArtifact: 'TelemetryArtifact',
    TelemetryMetricPoint: 'TelemetryMetricPoint',
    CredentialInstance: 'CredentialInstance',
    CredentialSecretMaterial: 'CredentialSecretMaterial',
    CredentialOAuth2Material: 'CredentialOAuth2Material',
    CredentialOAuth2State: 'CredentialOAuth2State',
    CredentialBinding: 'CredentialBinding',
    CredentialTestResult: 'CredentialTestResult',
    User: 'User',
    UserInvite: 'UserInvite',
    Account: 'Account',
    Session: 'Session',
    VerificationToken: 'VerificationToken',
    WorkflowAuditLog: 'WorkflowAuditLog',
    HmacNonce: 'HmacNonce',
    HumanTask: 'HumanTask'
  };

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



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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions
    }
    meta: {
      modelProps: "run" | "runWorkItem" | "executionInstance" | "runSlotProjection" | "testSuiteRun" | "testAssertion" | "workflowDebuggerOverlay" | "workflowActivation" | "triggerSetupState" | "runTraceContext" | "telemetrySpan" | "workflowSnapshot" | "telemetryArtifact" | "telemetryMetricPoint" | "credentialInstance" | "credentialSecretMaterial" | "credentialOAuth2Material" | "credentialOAuth2State" | "credentialBinding" | "credentialTestResult" | "user" | "userInvite" | "account" | "session" | "verificationToken" | "workflowAuditLog" | "hmacNonce" | "humanTask"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      Run: {
        payload: Prisma.$RunPayload<ExtArgs>
        fields: Prisma.RunFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RunFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RunFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>
          }
          findFirst: {
            args: Prisma.RunFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RunFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>
          }
          findMany: {
            args: Prisma.RunFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>[]
          }
          create: {
            args: Prisma.RunCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>
          }
          createMany: {
            args: Prisma.RunCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RunCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>[]
          }
          delete: {
            args: Prisma.RunDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>
          }
          update: {
            args: Prisma.RunUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>
          }
          deleteMany: {
            args: Prisma.RunDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RunUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.RunUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>[]
          }
          upsert: {
            args: Prisma.RunUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunPayload>
          }
          aggregate: {
            args: Prisma.RunAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRun>
          }
          groupBy: {
            args: Prisma.RunGroupByArgs<ExtArgs>
            result: $Utils.Optional<RunGroupByOutputType>[]
          }
          count: {
            args: Prisma.RunCountArgs<ExtArgs>
            result: $Utils.Optional<RunCountAggregateOutputType> | number
          }
        }
      }
      RunWorkItem: {
        payload: Prisma.$RunWorkItemPayload<ExtArgs>
        fields: Prisma.RunWorkItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RunWorkItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RunWorkItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>
          }
          findFirst: {
            args: Prisma.RunWorkItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RunWorkItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>
          }
          findMany: {
            args: Prisma.RunWorkItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>[]
          }
          create: {
            args: Prisma.RunWorkItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>
          }
          createMany: {
            args: Prisma.RunWorkItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RunWorkItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>[]
          }
          delete: {
            args: Prisma.RunWorkItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>
          }
          update: {
            args: Prisma.RunWorkItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>
          }
          deleteMany: {
            args: Prisma.RunWorkItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RunWorkItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.RunWorkItemUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>[]
          }
          upsert: {
            args: Prisma.RunWorkItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunWorkItemPayload>
          }
          aggregate: {
            args: Prisma.RunWorkItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRunWorkItem>
          }
          groupBy: {
            args: Prisma.RunWorkItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<RunWorkItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.RunWorkItemCountArgs<ExtArgs>
            result: $Utils.Optional<RunWorkItemCountAggregateOutputType> | number
          }
        }
      }
      ExecutionInstance: {
        payload: Prisma.$ExecutionInstancePayload<ExtArgs>
        fields: Prisma.ExecutionInstanceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExecutionInstanceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExecutionInstanceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>
          }
          findFirst: {
            args: Prisma.ExecutionInstanceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExecutionInstanceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>
          }
          findMany: {
            args: Prisma.ExecutionInstanceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>[]
          }
          create: {
            args: Prisma.ExecutionInstanceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>
          }
          createMany: {
            args: Prisma.ExecutionInstanceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ExecutionInstanceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>[]
          }
          delete: {
            args: Prisma.ExecutionInstanceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>
          }
          update: {
            args: Prisma.ExecutionInstanceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>
          }
          deleteMany: {
            args: Prisma.ExecutionInstanceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExecutionInstanceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ExecutionInstanceUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>[]
          }
          upsert: {
            args: Prisma.ExecutionInstanceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExecutionInstancePayload>
          }
          aggregate: {
            args: Prisma.ExecutionInstanceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExecutionInstance>
          }
          groupBy: {
            args: Prisma.ExecutionInstanceGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExecutionInstanceGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExecutionInstanceCountArgs<ExtArgs>
            result: $Utils.Optional<ExecutionInstanceCountAggregateOutputType> | number
          }
        }
      }
      RunSlotProjection: {
        payload: Prisma.$RunSlotProjectionPayload<ExtArgs>
        fields: Prisma.RunSlotProjectionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RunSlotProjectionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RunSlotProjectionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>
          }
          findFirst: {
            args: Prisma.RunSlotProjectionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RunSlotProjectionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>
          }
          findMany: {
            args: Prisma.RunSlotProjectionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>[]
          }
          create: {
            args: Prisma.RunSlotProjectionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>
          }
          createMany: {
            args: Prisma.RunSlotProjectionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RunSlotProjectionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>[]
          }
          delete: {
            args: Prisma.RunSlotProjectionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>
          }
          update: {
            args: Prisma.RunSlotProjectionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>
          }
          deleteMany: {
            args: Prisma.RunSlotProjectionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RunSlotProjectionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.RunSlotProjectionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>[]
          }
          upsert: {
            args: Prisma.RunSlotProjectionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunSlotProjectionPayload>
          }
          aggregate: {
            args: Prisma.RunSlotProjectionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRunSlotProjection>
          }
          groupBy: {
            args: Prisma.RunSlotProjectionGroupByArgs<ExtArgs>
            result: $Utils.Optional<RunSlotProjectionGroupByOutputType>[]
          }
          count: {
            args: Prisma.RunSlotProjectionCountArgs<ExtArgs>
            result: $Utils.Optional<RunSlotProjectionCountAggregateOutputType> | number
          }
        }
      }
      TestSuiteRun: {
        payload: Prisma.$TestSuiteRunPayload<ExtArgs>
        fields: Prisma.TestSuiteRunFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TestSuiteRunFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TestSuiteRunFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>
          }
          findFirst: {
            args: Prisma.TestSuiteRunFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TestSuiteRunFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>
          }
          findMany: {
            args: Prisma.TestSuiteRunFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>[]
          }
          create: {
            args: Prisma.TestSuiteRunCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>
          }
          createMany: {
            args: Prisma.TestSuiteRunCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TestSuiteRunCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>[]
          }
          delete: {
            args: Prisma.TestSuiteRunDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>
          }
          update: {
            args: Prisma.TestSuiteRunUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>
          }
          deleteMany: {
            args: Prisma.TestSuiteRunDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TestSuiteRunUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TestSuiteRunUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>[]
          }
          upsert: {
            args: Prisma.TestSuiteRunUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestSuiteRunPayload>
          }
          aggregate: {
            args: Prisma.TestSuiteRunAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTestSuiteRun>
          }
          groupBy: {
            args: Prisma.TestSuiteRunGroupByArgs<ExtArgs>
            result: $Utils.Optional<TestSuiteRunGroupByOutputType>[]
          }
          count: {
            args: Prisma.TestSuiteRunCountArgs<ExtArgs>
            result: $Utils.Optional<TestSuiteRunCountAggregateOutputType> | number
          }
        }
      }
      TestAssertion: {
        payload: Prisma.$TestAssertionPayload<ExtArgs>
        fields: Prisma.TestAssertionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TestAssertionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TestAssertionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>
          }
          findFirst: {
            args: Prisma.TestAssertionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TestAssertionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>
          }
          findMany: {
            args: Prisma.TestAssertionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>[]
          }
          create: {
            args: Prisma.TestAssertionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>
          }
          createMany: {
            args: Prisma.TestAssertionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TestAssertionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>[]
          }
          delete: {
            args: Prisma.TestAssertionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>
          }
          update: {
            args: Prisma.TestAssertionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>
          }
          deleteMany: {
            args: Prisma.TestAssertionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TestAssertionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TestAssertionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>[]
          }
          upsert: {
            args: Prisma.TestAssertionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TestAssertionPayload>
          }
          aggregate: {
            args: Prisma.TestAssertionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTestAssertion>
          }
          groupBy: {
            args: Prisma.TestAssertionGroupByArgs<ExtArgs>
            result: $Utils.Optional<TestAssertionGroupByOutputType>[]
          }
          count: {
            args: Prisma.TestAssertionCountArgs<ExtArgs>
            result: $Utils.Optional<TestAssertionCountAggregateOutputType> | number
          }
        }
      }
      WorkflowDebuggerOverlay: {
        payload: Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>
        fields: Prisma.WorkflowDebuggerOverlayFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WorkflowDebuggerOverlayFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WorkflowDebuggerOverlayFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>
          }
          findFirst: {
            args: Prisma.WorkflowDebuggerOverlayFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WorkflowDebuggerOverlayFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>
          }
          findMany: {
            args: Prisma.WorkflowDebuggerOverlayFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>[]
          }
          create: {
            args: Prisma.WorkflowDebuggerOverlayCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>
          }
          createMany: {
            args: Prisma.WorkflowDebuggerOverlayCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WorkflowDebuggerOverlayCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>[]
          }
          delete: {
            args: Prisma.WorkflowDebuggerOverlayDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>
          }
          update: {
            args: Prisma.WorkflowDebuggerOverlayUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>
          }
          deleteMany: {
            args: Prisma.WorkflowDebuggerOverlayDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WorkflowDebuggerOverlayUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.WorkflowDebuggerOverlayUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>[]
          }
          upsert: {
            args: Prisma.WorkflowDebuggerOverlayUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowDebuggerOverlayPayload>
          }
          aggregate: {
            args: Prisma.WorkflowDebuggerOverlayAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWorkflowDebuggerOverlay>
          }
          groupBy: {
            args: Prisma.WorkflowDebuggerOverlayGroupByArgs<ExtArgs>
            result: $Utils.Optional<WorkflowDebuggerOverlayGroupByOutputType>[]
          }
          count: {
            args: Prisma.WorkflowDebuggerOverlayCountArgs<ExtArgs>
            result: $Utils.Optional<WorkflowDebuggerOverlayCountAggregateOutputType> | number
          }
        }
      }
      WorkflowActivation: {
        payload: Prisma.$WorkflowActivationPayload<ExtArgs>
        fields: Prisma.WorkflowActivationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WorkflowActivationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WorkflowActivationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>
          }
          findFirst: {
            args: Prisma.WorkflowActivationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WorkflowActivationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>
          }
          findMany: {
            args: Prisma.WorkflowActivationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>[]
          }
          create: {
            args: Prisma.WorkflowActivationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>
          }
          createMany: {
            args: Prisma.WorkflowActivationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WorkflowActivationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>[]
          }
          delete: {
            args: Prisma.WorkflowActivationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>
          }
          update: {
            args: Prisma.WorkflowActivationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>
          }
          deleteMany: {
            args: Prisma.WorkflowActivationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WorkflowActivationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.WorkflowActivationUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>[]
          }
          upsert: {
            args: Prisma.WorkflowActivationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowActivationPayload>
          }
          aggregate: {
            args: Prisma.WorkflowActivationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWorkflowActivation>
          }
          groupBy: {
            args: Prisma.WorkflowActivationGroupByArgs<ExtArgs>
            result: $Utils.Optional<WorkflowActivationGroupByOutputType>[]
          }
          count: {
            args: Prisma.WorkflowActivationCountArgs<ExtArgs>
            result: $Utils.Optional<WorkflowActivationCountAggregateOutputType> | number
          }
        }
      }
      TriggerSetupState: {
        payload: Prisma.$TriggerSetupStatePayload<ExtArgs>
        fields: Prisma.TriggerSetupStateFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TriggerSetupStateFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TriggerSetupStateFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>
          }
          findFirst: {
            args: Prisma.TriggerSetupStateFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TriggerSetupStateFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>
          }
          findMany: {
            args: Prisma.TriggerSetupStateFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>[]
          }
          create: {
            args: Prisma.TriggerSetupStateCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>
          }
          createMany: {
            args: Prisma.TriggerSetupStateCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TriggerSetupStateCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>[]
          }
          delete: {
            args: Prisma.TriggerSetupStateDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>
          }
          update: {
            args: Prisma.TriggerSetupStateUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>
          }
          deleteMany: {
            args: Prisma.TriggerSetupStateDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TriggerSetupStateUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TriggerSetupStateUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>[]
          }
          upsert: {
            args: Prisma.TriggerSetupStateUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TriggerSetupStatePayload>
          }
          aggregate: {
            args: Prisma.TriggerSetupStateAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTriggerSetupState>
          }
          groupBy: {
            args: Prisma.TriggerSetupStateGroupByArgs<ExtArgs>
            result: $Utils.Optional<TriggerSetupStateGroupByOutputType>[]
          }
          count: {
            args: Prisma.TriggerSetupStateCountArgs<ExtArgs>
            result: $Utils.Optional<TriggerSetupStateCountAggregateOutputType> | number
          }
        }
      }
      RunTraceContext: {
        payload: Prisma.$RunTraceContextPayload<ExtArgs>
        fields: Prisma.RunTraceContextFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RunTraceContextFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RunTraceContextFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>
          }
          findFirst: {
            args: Prisma.RunTraceContextFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RunTraceContextFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>
          }
          findMany: {
            args: Prisma.RunTraceContextFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>[]
          }
          create: {
            args: Prisma.RunTraceContextCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>
          }
          createMany: {
            args: Prisma.RunTraceContextCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RunTraceContextCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>[]
          }
          delete: {
            args: Prisma.RunTraceContextDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>
          }
          update: {
            args: Prisma.RunTraceContextUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>
          }
          deleteMany: {
            args: Prisma.RunTraceContextDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RunTraceContextUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.RunTraceContextUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>[]
          }
          upsert: {
            args: Prisma.RunTraceContextUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RunTraceContextPayload>
          }
          aggregate: {
            args: Prisma.RunTraceContextAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRunTraceContext>
          }
          groupBy: {
            args: Prisma.RunTraceContextGroupByArgs<ExtArgs>
            result: $Utils.Optional<RunTraceContextGroupByOutputType>[]
          }
          count: {
            args: Prisma.RunTraceContextCountArgs<ExtArgs>
            result: $Utils.Optional<RunTraceContextCountAggregateOutputType> | number
          }
        }
      }
      TelemetrySpan: {
        payload: Prisma.$TelemetrySpanPayload<ExtArgs>
        fields: Prisma.TelemetrySpanFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TelemetrySpanFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TelemetrySpanFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>
          }
          findFirst: {
            args: Prisma.TelemetrySpanFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TelemetrySpanFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>
          }
          findMany: {
            args: Prisma.TelemetrySpanFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>[]
          }
          create: {
            args: Prisma.TelemetrySpanCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>
          }
          createMany: {
            args: Prisma.TelemetrySpanCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TelemetrySpanCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>[]
          }
          delete: {
            args: Prisma.TelemetrySpanDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>
          }
          update: {
            args: Prisma.TelemetrySpanUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>
          }
          deleteMany: {
            args: Prisma.TelemetrySpanDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TelemetrySpanUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TelemetrySpanUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>[]
          }
          upsert: {
            args: Prisma.TelemetrySpanUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetrySpanPayload>
          }
          aggregate: {
            args: Prisma.TelemetrySpanAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTelemetrySpan>
          }
          groupBy: {
            args: Prisma.TelemetrySpanGroupByArgs<ExtArgs>
            result: $Utils.Optional<TelemetrySpanGroupByOutputType>[]
          }
          count: {
            args: Prisma.TelemetrySpanCountArgs<ExtArgs>
            result: $Utils.Optional<TelemetrySpanCountAggregateOutputType> | number
          }
        }
      }
      WorkflowSnapshot: {
        payload: Prisma.$WorkflowSnapshotPayload<ExtArgs>
        fields: Prisma.WorkflowSnapshotFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WorkflowSnapshotFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WorkflowSnapshotFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>
          }
          findFirst: {
            args: Prisma.WorkflowSnapshotFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WorkflowSnapshotFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>
          }
          findMany: {
            args: Prisma.WorkflowSnapshotFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>[]
          }
          create: {
            args: Prisma.WorkflowSnapshotCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>
          }
          createMany: {
            args: Prisma.WorkflowSnapshotCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WorkflowSnapshotCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>[]
          }
          delete: {
            args: Prisma.WorkflowSnapshotDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>
          }
          update: {
            args: Prisma.WorkflowSnapshotUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>
          }
          deleteMany: {
            args: Prisma.WorkflowSnapshotDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WorkflowSnapshotUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.WorkflowSnapshotUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>[]
          }
          upsert: {
            args: Prisma.WorkflowSnapshotUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowSnapshotPayload>
          }
          aggregate: {
            args: Prisma.WorkflowSnapshotAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWorkflowSnapshot>
          }
          groupBy: {
            args: Prisma.WorkflowSnapshotGroupByArgs<ExtArgs>
            result: $Utils.Optional<WorkflowSnapshotGroupByOutputType>[]
          }
          count: {
            args: Prisma.WorkflowSnapshotCountArgs<ExtArgs>
            result: $Utils.Optional<WorkflowSnapshotCountAggregateOutputType> | number
          }
        }
      }
      TelemetryArtifact: {
        payload: Prisma.$TelemetryArtifactPayload<ExtArgs>
        fields: Prisma.TelemetryArtifactFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TelemetryArtifactFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TelemetryArtifactFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>
          }
          findFirst: {
            args: Prisma.TelemetryArtifactFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TelemetryArtifactFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>
          }
          findMany: {
            args: Prisma.TelemetryArtifactFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>[]
          }
          create: {
            args: Prisma.TelemetryArtifactCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>
          }
          createMany: {
            args: Prisma.TelemetryArtifactCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TelemetryArtifactCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>[]
          }
          delete: {
            args: Prisma.TelemetryArtifactDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>
          }
          update: {
            args: Prisma.TelemetryArtifactUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>
          }
          deleteMany: {
            args: Prisma.TelemetryArtifactDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TelemetryArtifactUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TelemetryArtifactUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>[]
          }
          upsert: {
            args: Prisma.TelemetryArtifactUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryArtifactPayload>
          }
          aggregate: {
            args: Prisma.TelemetryArtifactAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTelemetryArtifact>
          }
          groupBy: {
            args: Prisma.TelemetryArtifactGroupByArgs<ExtArgs>
            result: $Utils.Optional<TelemetryArtifactGroupByOutputType>[]
          }
          count: {
            args: Prisma.TelemetryArtifactCountArgs<ExtArgs>
            result: $Utils.Optional<TelemetryArtifactCountAggregateOutputType> | number
          }
        }
      }
      TelemetryMetricPoint: {
        payload: Prisma.$TelemetryMetricPointPayload<ExtArgs>
        fields: Prisma.TelemetryMetricPointFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TelemetryMetricPointFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TelemetryMetricPointFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>
          }
          findFirst: {
            args: Prisma.TelemetryMetricPointFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TelemetryMetricPointFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>
          }
          findMany: {
            args: Prisma.TelemetryMetricPointFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>[]
          }
          create: {
            args: Prisma.TelemetryMetricPointCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>
          }
          createMany: {
            args: Prisma.TelemetryMetricPointCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TelemetryMetricPointCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>[]
          }
          delete: {
            args: Prisma.TelemetryMetricPointDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>
          }
          update: {
            args: Prisma.TelemetryMetricPointUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>
          }
          deleteMany: {
            args: Prisma.TelemetryMetricPointDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TelemetryMetricPointUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TelemetryMetricPointUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>[]
          }
          upsert: {
            args: Prisma.TelemetryMetricPointUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TelemetryMetricPointPayload>
          }
          aggregate: {
            args: Prisma.TelemetryMetricPointAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTelemetryMetricPoint>
          }
          groupBy: {
            args: Prisma.TelemetryMetricPointGroupByArgs<ExtArgs>
            result: $Utils.Optional<TelemetryMetricPointGroupByOutputType>[]
          }
          count: {
            args: Prisma.TelemetryMetricPointCountArgs<ExtArgs>
            result: $Utils.Optional<TelemetryMetricPointCountAggregateOutputType> | number
          }
        }
      }
      CredentialInstance: {
        payload: Prisma.$CredentialInstancePayload<ExtArgs>
        fields: Prisma.CredentialInstanceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CredentialInstanceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CredentialInstanceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>
          }
          findFirst: {
            args: Prisma.CredentialInstanceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CredentialInstanceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>
          }
          findMany: {
            args: Prisma.CredentialInstanceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>[]
          }
          create: {
            args: Prisma.CredentialInstanceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>
          }
          createMany: {
            args: Prisma.CredentialInstanceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CredentialInstanceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>[]
          }
          delete: {
            args: Prisma.CredentialInstanceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>
          }
          update: {
            args: Prisma.CredentialInstanceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>
          }
          deleteMany: {
            args: Prisma.CredentialInstanceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CredentialInstanceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CredentialInstanceUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>[]
          }
          upsert: {
            args: Prisma.CredentialInstanceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialInstancePayload>
          }
          aggregate: {
            args: Prisma.CredentialInstanceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCredentialInstance>
          }
          groupBy: {
            args: Prisma.CredentialInstanceGroupByArgs<ExtArgs>
            result: $Utils.Optional<CredentialInstanceGroupByOutputType>[]
          }
          count: {
            args: Prisma.CredentialInstanceCountArgs<ExtArgs>
            result: $Utils.Optional<CredentialInstanceCountAggregateOutputType> | number
          }
        }
      }
      CredentialSecretMaterial: {
        payload: Prisma.$CredentialSecretMaterialPayload<ExtArgs>
        fields: Prisma.CredentialSecretMaterialFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CredentialSecretMaterialFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CredentialSecretMaterialFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>
          }
          findFirst: {
            args: Prisma.CredentialSecretMaterialFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CredentialSecretMaterialFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>
          }
          findMany: {
            args: Prisma.CredentialSecretMaterialFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>[]
          }
          create: {
            args: Prisma.CredentialSecretMaterialCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>
          }
          createMany: {
            args: Prisma.CredentialSecretMaterialCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CredentialSecretMaterialCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>[]
          }
          delete: {
            args: Prisma.CredentialSecretMaterialDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>
          }
          update: {
            args: Prisma.CredentialSecretMaterialUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>
          }
          deleteMany: {
            args: Prisma.CredentialSecretMaterialDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CredentialSecretMaterialUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CredentialSecretMaterialUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>[]
          }
          upsert: {
            args: Prisma.CredentialSecretMaterialUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialSecretMaterialPayload>
          }
          aggregate: {
            args: Prisma.CredentialSecretMaterialAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCredentialSecretMaterial>
          }
          groupBy: {
            args: Prisma.CredentialSecretMaterialGroupByArgs<ExtArgs>
            result: $Utils.Optional<CredentialSecretMaterialGroupByOutputType>[]
          }
          count: {
            args: Prisma.CredentialSecretMaterialCountArgs<ExtArgs>
            result: $Utils.Optional<CredentialSecretMaterialCountAggregateOutputType> | number
          }
        }
      }
      CredentialOAuth2Material: {
        payload: Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>
        fields: Prisma.CredentialOAuth2MaterialFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CredentialOAuth2MaterialFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CredentialOAuth2MaterialFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>
          }
          findFirst: {
            args: Prisma.CredentialOAuth2MaterialFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CredentialOAuth2MaterialFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>
          }
          findMany: {
            args: Prisma.CredentialOAuth2MaterialFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>[]
          }
          create: {
            args: Prisma.CredentialOAuth2MaterialCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>
          }
          createMany: {
            args: Prisma.CredentialOAuth2MaterialCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CredentialOAuth2MaterialCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>[]
          }
          delete: {
            args: Prisma.CredentialOAuth2MaterialDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>
          }
          update: {
            args: Prisma.CredentialOAuth2MaterialUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>
          }
          deleteMany: {
            args: Prisma.CredentialOAuth2MaterialDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CredentialOAuth2MaterialUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CredentialOAuth2MaterialUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>[]
          }
          upsert: {
            args: Prisma.CredentialOAuth2MaterialUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2MaterialPayload>
          }
          aggregate: {
            args: Prisma.CredentialOAuth2MaterialAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCredentialOAuth2Material>
          }
          groupBy: {
            args: Prisma.CredentialOAuth2MaterialGroupByArgs<ExtArgs>
            result: $Utils.Optional<CredentialOAuth2MaterialGroupByOutputType>[]
          }
          count: {
            args: Prisma.CredentialOAuth2MaterialCountArgs<ExtArgs>
            result: $Utils.Optional<CredentialOAuth2MaterialCountAggregateOutputType> | number
          }
        }
      }
      CredentialOAuth2State: {
        payload: Prisma.$CredentialOAuth2StatePayload<ExtArgs>
        fields: Prisma.CredentialOAuth2StateFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CredentialOAuth2StateFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CredentialOAuth2StateFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>
          }
          findFirst: {
            args: Prisma.CredentialOAuth2StateFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CredentialOAuth2StateFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>
          }
          findMany: {
            args: Prisma.CredentialOAuth2StateFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>[]
          }
          create: {
            args: Prisma.CredentialOAuth2StateCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>
          }
          createMany: {
            args: Prisma.CredentialOAuth2StateCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CredentialOAuth2StateCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>[]
          }
          delete: {
            args: Prisma.CredentialOAuth2StateDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>
          }
          update: {
            args: Prisma.CredentialOAuth2StateUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>
          }
          deleteMany: {
            args: Prisma.CredentialOAuth2StateDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CredentialOAuth2StateUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CredentialOAuth2StateUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>[]
          }
          upsert: {
            args: Prisma.CredentialOAuth2StateUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialOAuth2StatePayload>
          }
          aggregate: {
            args: Prisma.CredentialOAuth2StateAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCredentialOAuth2State>
          }
          groupBy: {
            args: Prisma.CredentialOAuth2StateGroupByArgs<ExtArgs>
            result: $Utils.Optional<CredentialOAuth2StateGroupByOutputType>[]
          }
          count: {
            args: Prisma.CredentialOAuth2StateCountArgs<ExtArgs>
            result: $Utils.Optional<CredentialOAuth2StateCountAggregateOutputType> | number
          }
        }
      }
      CredentialBinding: {
        payload: Prisma.$CredentialBindingPayload<ExtArgs>
        fields: Prisma.CredentialBindingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CredentialBindingFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CredentialBindingFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>
          }
          findFirst: {
            args: Prisma.CredentialBindingFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CredentialBindingFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>
          }
          findMany: {
            args: Prisma.CredentialBindingFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>[]
          }
          create: {
            args: Prisma.CredentialBindingCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>
          }
          createMany: {
            args: Prisma.CredentialBindingCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CredentialBindingCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>[]
          }
          delete: {
            args: Prisma.CredentialBindingDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>
          }
          update: {
            args: Prisma.CredentialBindingUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>
          }
          deleteMany: {
            args: Prisma.CredentialBindingDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CredentialBindingUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CredentialBindingUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>[]
          }
          upsert: {
            args: Prisma.CredentialBindingUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialBindingPayload>
          }
          aggregate: {
            args: Prisma.CredentialBindingAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCredentialBinding>
          }
          groupBy: {
            args: Prisma.CredentialBindingGroupByArgs<ExtArgs>
            result: $Utils.Optional<CredentialBindingGroupByOutputType>[]
          }
          count: {
            args: Prisma.CredentialBindingCountArgs<ExtArgs>
            result: $Utils.Optional<CredentialBindingCountAggregateOutputType> | number
          }
        }
      }
      CredentialTestResult: {
        payload: Prisma.$CredentialTestResultPayload<ExtArgs>
        fields: Prisma.CredentialTestResultFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CredentialTestResultFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CredentialTestResultFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>
          }
          findFirst: {
            args: Prisma.CredentialTestResultFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CredentialTestResultFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>
          }
          findMany: {
            args: Prisma.CredentialTestResultFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>[]
          }
          create: {
            args: Prisma.CredentialTestResultCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>
          }
          createMany: {
            args: Prisma.CredentialTestResultCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CredentialTestResultCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>[]
          }
          delete: {
            args: Prisma.CredentialTestResultDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>
          }
          update: {
            args: Prisma.CredentialTestResultUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>
          }
          deleteMany: {
            args: Prisma.CredentialTestResultDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CredentialTestResultUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CredentialTestResultUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>[]
          }
          upsert: {
            args: Prisma.CredentialTestResultUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CredentialTestResultPayload>
          }
          aggregate: {
            args: Prisma.CredentialTestResultAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCredentialTestResult>
          }
          groupBy: {
            args: Prisma.CredentialTestResultGroupByArgs<ExtArgs>
            result: $Utils.Optional<CredentialTestResultGroupByOutputType>[]
          }
          count: {
            args: Prisma.CredentialTestResultCountArgs<ExtArgs>
            result: $Utils.Optional<CredentialTestResultCountAggregateOutputType> | number
          }
        }
      }
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      UserInvite: {
        payload: Prisma.$UserInvitePayload<ExtArgs>
        fields: Prisma.UserInviteFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserInviteFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserInviteFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>
          }
          findFirst: {
            args: Prisma.UserInviteFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserInviteFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>
          }
          findMany: {
            args: Prisma.UserInviteFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>[]
          }
          create: {
            args: Prisma.UserInviteCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>
          }
          createMany: {
            args: Prisma.UserInviteCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserInviteCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>[]
          }
          delete: {
            args: Prisma.UserInviteDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>
          }
          update: {
            args: Prisma.UserInviteUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>
          }
          deleteMany: {
            args: Prisma.UserInviteDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserInviteUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.UserInviteUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>[]
          }
          upsert: {
            args: Prisma.UserInviteUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserInvitePayload>
          }
          aggregate: {
            args: Prisma.UserInviteAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUserInvite>
          }
          groupBy: {
            args: Prisma.UserInviteGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserInviteGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserInviteCountArgs<ExtArgs>
            result: $Utils.Optional<UserInviteCountAggregateOutputType> | number
          }
        }
      }
      Account: {
        payload: Prisma.$AccountPayload<ExtArgs>
        fields: Prisma.AccountFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AccountFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AccountFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findFirst: {
            args: Prisma.AccountFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AccountFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findMany: {
            args: Prisma.AccountFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          create: {
            args: Prisma.AccountCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          createMany: {
            args: Prisma.AccountCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AccountCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          delete: {
            args: Prisma.AccountDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          update: {
            args: Prisma.AccountUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          deleteMany: {
            args: Prisma.AccountDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AccountUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AccountUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          upsert: {
            args: Prisma.AccountUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          aggregate: {
            args: Prisma.AccountAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAccount>
          }
          groupBy: {
            args: Prisma.AccountGroupByArgs<ExtArgs>
            result: $Utils.Optional<AccountGroupByOutputType>[]
          }
          count: {
            args: Prisma.AccountCountArgs<ExtArgs>
            result: $Utils.Optional<AccountCountAggregateOutputType> | number
          }
        }
      }
      Session: {
        payload: Prisma.$SessionPayload<ExtArgs>
        fields: Prisma.SessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findFirst: {
            args: Prisma.SessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findMany: {
            args: Prisma.SessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          create: {
            args: Prisma.SessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          createMany: {
            args: Prisma.SessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          delete: {
            args: Prisma.SessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          update: {
            args: Prisma.SessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          deleteMany: {
            args: Prisma.SessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          upsert: {
            args: Prisma.SessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          aggregate: {
            args: Prisma.SessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSession>
          }
          groupBy: {
            args: Prisma.SessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SessionCountArgs<ExtArgs>
            result: $Utils.Optional<SessionCountAggregateOutputType> | number
          }
        }
      }
      VerificationToken: {
        payload: Prisma.$VerificationTokenPayload<ExtArgs>
        fields: Prisma.VerificationTokenFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VerificationTokenFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VerificationTokenFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
          }
          findFirst: {
            args: Prisma.VerificationTokenFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VerificationTokenFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
          }
          findMany: {
            args: Prisma.VerificationTokenFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
          }
          create: {
            args: Prisma.VerificationTokenCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
          }
          createMany: {
            args: Prisma.VerificationTokenCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.VerificationTokenCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
          }
          delete: {
            args: Prisma.VerificationTokenDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
          }
          update: {
            args: Prisma.VerificationTokenUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
          }
          deleteMany: {
            args: Prisma.VerificationTokenDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VerificationTokenUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.VerificationTokenUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
          }
          upsert: {
            args: Prisma.VerificationTokenUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
          }
          aggregate: {
            args: Prisma.VerificationTokenAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVerificationToken>
          }
          groupBy: {
            args: Prisma.VerificationTokenGroupByArgs<ExtArgs>
            result: $Utils.Optional<VerificationTokenGroupByOutputType>[]
          }
          count: {
            args: Prisma.VerificationTokenCountArgs<ExtArgs>
            result: $Utils.Optional<VerificationTokenCountAggregateOutputType> | number
          }
        }
      }
      WorkflowAuditLog: {
        payload: Prisma.$WorkflowAuditLogPayload<ExtArgs>
        fields: Prisma.WorkflowAuditLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WorkflowAuditLogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WorkflowAuditLogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>
          }
          findFirst: {
            args: Prisma.WorkflowAuditLogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WorkflowAuditLogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>
          }
          findMany: {
            args: Prisma.WorkflowAuditLogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>[]
          }
          create: {
            args: Prisma.WorkflowAuditLogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>
          }
          createMany: {
            args: Prisma.WorkflowAuditLogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WorkflowAuditLogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>[]
          }
          delete: {
            args: Prisma.WorkflowAuditLogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>
          }
          update: {
            args: Prisma.WorkflowAuditLogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>
          }
          deleteMany: {
            args: Prisma.WorkflowAuditLogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WorkflowAuditLogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.WorkflowAuditLogUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>[]
          }
          upsert: {
            args: Prisma.WorkflowAuditLogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkflowAuditLogPayload>
          }
          aggregate: {
            args: Prisma.WorkflowAuditLogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWorkflowAuditLog>
          }
          groupBy: {
            args: Prisma.WorkflowAuditLogGroupByArgs<ExtArgs>
            result: $Utils.Optional<WorkflowAuditLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.WorkflowAuditLogCountArgs<ExtArgs>
            result: $Utils.Optional<WorkflowAuditLogCountAggregateOutputType> | number
          }
        }
      }
      HmacNonce: {
        payload: Prisma.$HmacNoncePayload<ExtArgs>
        fields: Prisma.HmacNonceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.HmacNonceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.HmacNonceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>
          }
          findFirst: {
            args: Prisma.HmacNonceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.HmacNonceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>
          }
          findMany: {
            args: Prisma.HmacNonceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>[]
          }
          create: {
            args: Prisma.HmacNonceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>
          }
          createMany: {
            args: Prisma.HmacNonceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.HmacNonceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>[]
          }
          delete: {
            args: Prisma.HmacNonceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>
          }
          update: {
            args: Prisma.HmacNonceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>
          }
          deleteMany: {
            args: Prisma.HmacNonceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.HmacNonceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.HmacNonceUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>[]
          }
          upsert: {
            args: Prisma.HmacNonceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HmacNoncePayload>
          }
          aggregate: {
            args: Prisma.HmacNonceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateHmacNonce>
          }
          groupBy: {
            args: Prisma.HmacNonceGroupByArgs<ExtArgs>
            result: $Utils.Optional<HmacNonceGroupByOutputType>[]
          }
          count: {
            args: Prisma.HmacNonceCountArgs<ExtArgs>
            result: $Utils.Optional<HmacNonceCountAggregateOutputType> | number
          }
        }
      }
      HumanTask: {
        payload: Prisma.$HumanTaskPayload<ExtArgs>
        fields: Prisma.HumanTaskFieldRefs
        operations: {
          findUnique: {
            args: Prisma.HumanTaskFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.HumanTaskFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>
          }
          findFirst: {
            args: Prisma.HumanTaskFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.HumanTaskFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>
          }
          findMany: {
            args: Prisma.HumanTaskFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>[]
          }
          create: {
            args: Prisma.HumanTaskCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>
          }
          createMany: {
            args: Prisma.HumanTaskCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.HumanTaskCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>[]
          }
          delete: {
            args: Prisma.HumanTaskDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>
          }
          update: {
            args: Prisma.HumanTaskUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>
          }
          deleteMany: {
            args: Prisma.HumanTaskDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.HumanTaskUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.HumanTaskUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>[]
          }
          upsert: {
            args: Prisma.HumanTaskUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HumanTaskPayload>
          }
          aggregate: {
            args: Prisma.HumanTaskAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateHumanTask>
          }
          groupBy: {
            args: Prisma.HumanTaskGroupByArgs<ExtArgs>
            result: $Utils.Optional<HumanTaskGroupByOutputType>[]
          }
          count: {
            args: Prisma.HumanTaskCountArgs<ExtArgs>
            result: $Utils.Optional<HumanTaskCountAggregateOutputType> | 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 {
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Shorthand for `emit: 'stdout'`
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events only
     * log: [
     *   { emit: 'event', level: 'query' },
     *   { emit: 'event', level: 'info' },
     *   { emit: 'event', level: 'warn' }
     *   { emit: 'event', level: 'error' }
     * ]
     * 
     * / Emit as events and log to stdout
     * og: [
     *  { emit: 'stdout', level: 'query' },
     *  { emit: 'stdout', level: 'info' },
     *  { emit: 'stdout', level: 'warn' }
     *  { emit: 'stdout', level: 'error' }
     * 
     * ```
     * Read more in our [docs](https://pris.ly/d/logging).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
    /**
     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`
     */
    adapter?: runtime.SqlDriverAdapterFactory
    /**
     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
     */
    accelerateUrl?: string
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
    /**
     * SQL commenter plugins that add metadata to SQL queries as comments.
     * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   adapter,
     *   comments: [
     *     traceContext(),
     *     queryInsights(),
     *   ],
     * })
     * ```
     */
    comments?: runtime.SqlCommenterPlugin[]
  }
  export type GlobalOmitConfig = {
    run?: RunOmit
    runWorkItem?: RunWorkItemOmit
    executionInstance?: ExecutionInstanceOmit
    runSlotProjection?: RunSlotProjectionOmit
    testSuiteRun?: TestSuiteRunOmit
    testAssertion?: TestAssertionOmit
    workflowDebuggerOverlay?: WorkflowDebuggerOverlayOmit
    workflowActivation?: WorkflowActivationOmit
    triggerSetupState?: TriggerSetupStateOmit
    runTraceContext?: RunTraceContextOmit
    telemetrySpan?: TelemetrySpanOmit
    workflowSnapshot?: WorkflowSnapshotOmit
    telemetryArtifact?: TelemetryArtifactOmit
    telemetryMetricPoint?: TelemetryMetricPointOmit
    credentialInstance?: CredentialInstanceOmit
    credentialSecretMaterial?: CredentialSecretMaterialOmit
    credentialOAuth2Material?: CredentialOAuth2MaterialOmit
    credentialOAuth2State?: CredentialOAuth2StateOmit
    credentialBinding?: CredentialBindingOmit
    credentialTestResult?: CredentialTestResultOmit
    user?: UserOmit
    userInvite?: UserInviteOmit
    account?: AccountOmit
    session?: SessionOmit
    verificationToken?: VerificationTokenOmit
    workflowAuditLog?: WorkflowAuditLogOmit
    hmacNonce?: HmacNonceOmit
    humanTask?: HumanTaskOmit
  }

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

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

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

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

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

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


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

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

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

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */


  /**
   * Count Type RunCountOutputType
   */

  export type RunCountOutputType = {
    workItems: number
    executionInstances: number
    testAssertions: number
  }

  export type RunCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    workItems?: boolean | RunCountOutputTypeCountWorkItemsArgs
    executionInstances?: boolean | RunCountOutputTypeCountExecutionInstancesArgs
    testAssertions?: boolean | RunCountOutputTypeCountTestAssertionsArgs
  }

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

  /**
   * RunCountOutputType without action
   */
  export type RunCountOutputTypeCountWorkItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunWorkItemWhereInput
  }

  /**
   * RunCountOutputType without action
   */
  export type RunCountOutputTypeCountExecutionInstancesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExecutionInstanceWhereInput
  }

  /**
   * RunCountOutputType without action
   */
  export type RunCountOutputTypeCountTestAssertionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TestAssertionWhereInput
  }


  /**
   * Count Type TestSuiteRunCountOutputType
   */

  export type TestSuiteRunCountOutputType = {
    runs: number
    assertions: number
  }

  export type TestSuiteRunCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    runs?: boolean | TestSuiteRunCountOutputTypeCountRunsArgs
    assertions?: boolean | TestSuiteRunCountOutputTypeCountAssertionsArgs
  }

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

  /**
   * TestSuiteRunCountOutputType without action
   */
  export type TestSuiteRunCountOutputTypeCountRunsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunWhereInput
  }

  /**
   * TestSuiteRunCountOutputType without action
   */
  export type TestSuiteRunCountOutputTypeCountAssertionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TestAssertionWhereInput
  }


  /**
   * Count Type WorkflowSnapshotCountOutputType
   */

  export type WorkflowSnapshotCountOutputType = {
    runs: number
  }

  export type WorkflowSnapshotCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    runs?: boolean | WorkflowSnapshotCountOutputTypeCountRunsArgs
  }

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

  /**
   * WorkflowSnapshotCountOutputType without action
   */
  export type WorkflowSnapshotCountOutputTypeCountRunsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunWhereInput
  }


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    accounts: number
    sessions: number
    invites: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accounts?: boolean | UserCountOutputTypeCountAccountsArgs
    sessions?: boolean | UserCountOutputTypeCountSessionsArgs
    invites?: boolean | UserCountOutputTypeCountInvitesArgs
  }

  // 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 UserCountOutputTypeCountAccountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
  }

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

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


  /**
   * Models
   */

  /**
   * Model Run
   */

  export type AggregateRun = {
    _count: RunCountAggregateOutputType | null
    _avg: RunAvgAggregateOutputType | null
    _sum: RunSumAggregateOutputType | null
    _min: RunMinAggregateOutputType | null
    _max: RunMaxAggregateOutputType | null
  }

  export type RunAvgAggregateOutputType = {
    revision: number | null
    testCaseIndex: number | null
  }

  export type RunSumAggregateOutputType = {
    revision: number | null
    testCaseIndex: number | null
  }

  export type RunMinAggregateOutputType = {
    runId: string | null
    workflowId: string | null
    startedAt: string | null
    finishedAt: string | null
    status: string | null
    revision: number | null
    parentJson: string | null
    executionOptionsJson: string | null
    controlJson: string | null
    workflowSnapshotJson: string | null
    workflowSnapshotId: string | null
    policySnapshotJson: string | null
    engineCountersJson: string | null
    mutableStateJson: string | null
    hitlStateJson: string | null
    outputsByNodeJson: string | null
    updatedAt: string | null
    testSuiteRunId: string | null
    testCaseIndex: number | null
    testCaseLabel: string | null
    testCaseStatus: string | null
  }

  export type RunMaxAggregateOutputType = {
    runId: string | null
    workflowId: string | null
    startedAt: string | null
    finishedAt: string | null
    status: string | null
    revision: number | null
    parentJson: string | null
    executionOptionsJson: string | null
    controlJson: string | null
    workflowSnapshotJson: string | null
    workflowSnapshotId: string | null
    policySnapshotJson: string | null
    engineCountersJson: string | null
    mutableStateJson: string | null
    hitlStateJson: string | null
    outputsByNodeJson: string | null
    updatedAt: string | null
    testSuiteRunId: string | null
    testCaseIndex: number | null
    testCaseLabel: string | null
    testCaseStatus: string | null
  }

  export type RunCountAggregateOutputType = {
    runId: number
    workflowId: number
    startedAt: number
    finishedAt: number
    status: number
    revision: number
    parentJson: number
    executionOptionsJson: number
    controlJson: number
    workflowSnapshotJson: number
    workflowSnapshotId: number
    policySnapshotJson: number
    engineCountersJson: number
    mutableStateJson: number
    hitlStateJson: number
    outputsByNodeJson: number
    updatedAt: number
    testSuiteRunId: number
    testCaseIndex: number
    testCaseLabel: number
    testCaseStatus: number
    _all: number
  }


  export type RunAvgAggregateInputType = {
    revision?: true
    testCaseIndex?: true
  }

  export type RunSumAggregateInputType = {
    revision?: true
    testCaseIndex?: true
  }

  export type RunMinAggregateInputType = {
    runId?: true
    workflowId?: true
    startedAt?: true
    finishedAt?: true
    status?: true
    revision?: true
    parentJson?: true
    executionOptionsJson?: true
    controlJson?: true
    workflowSnapshotJson?: true
    workflowSnapshotId?: true
    policySnapshotJson?: true
    engineCountersJson?: true
    mutableStateJson?: true
    hitlStateJson?: true
    outputsByNodeJson?: true
    updatedAt?: true
    testSuiteRunId?: true
    testCaseIndex?: true
    testCaseLabel?: true
    testCaseStatus?: true
  }

  export type RunMaxAggregateInputType = {
    runId?: true
    workflowId?: true
    startedAt?: true
    finishedAt?: true
    status?: true
    revision?: true
    parentJson?: true
    executionOptionsJson?: true
    controlJson?: true
    workflowSnapshotJson?: true
    workflowSnapshotId?: true
    policySnapshotJson?: true
    engineCountersJson?: true
    mutableStateJson?: true
    hitlStateJson?: true
    outputsByNodeJson?: true
    updatedAt?: true
    testSuiteRunId?: true
    testCaseIndex?: true
    testCaseLabel?: true
    testCaseStatus?: true
  }

  export type RunCountAggregateInputType = {
    runId?: true
    workflowId?: true
    startedAt?: true
    finishedAt?: true
    status?: true
    revision?: true
    parentJson?: true
    executionOptionsJson?: true
    controlJson?: true
    workflowSnapshotJson?: true
    workflowSnapshotId?: true
    policySnapshotJson?: true
    engineCountersJson?: true
    mutableStateJson?: true
    hitlStateJson?: true
    outputsByNodeJson?: true
    updatedAt?: true
    testSuiteRunId?: true
    testCaseIndex?: true
    testCaseLabel?: true
    testCaseStatus?: true
    _all?: true
  }

  export type RunAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Run to aggregate.
     */
    where?: RunWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Runs to fetch.
     */
    orderBy?: RunOrderByWithRelationInput | RunOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: RunWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Runs 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` Runs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Runs
    **/
    _count?: true | RunCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: RunAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: RunSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: RunMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: RunMaxAggregateInputType
  }

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




  export type RunGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunWhereInput
    orderBy?: RunOrderByWithAggregationInput | RunOrderByWithAggregationInput[]
    by: RunScalarFieldEnum[] | RunScalarFieldEnum
    having?: RunScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RunCountAggregateInputType | true
    _avg?: RunAvgAggregateInputType
    _sum?: RunSumAggregateInputType
    _min?: RunMinAggregateInputType
    _max?: RunMaxAggregateInputType
  }

  export type RunGroupByOutputType = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt: string | null
    status: string
    revision: number
    parentJson: string | null
    executionOptionsJson: string | null
    controlJson: string | null
    workflowSnapshotJson: string | null
    workflowSnapshotId: string | null
    policySnapshotJson: string | null
    engineCountersJson: string | null
    mutableStateJson: string | null
    hitlStateJson: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId: string | null
    testCaseIndex: number | null
    testCaseLabel: string | null
    testCaseStatus: string | null
    _count: RunCountAggregateOutputType | null
    _avg: RunAvgAggregateOutputType | null
    _sum: RunSumAggregateOutputType | null
    _min: RunMinAggregateOutputType | null
    _max: RunMaxAggregateOutputType | null
  }

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


  export type RunSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    status?: boolean
    revision?: boolean
    parentJson?: boolean
    executionOptionsJson?: boolean
    controlJson?: boolean
    workflowSnapshotJson?: boolean
    workflowSnapshotId?: boolean
    policySnapshotJson?: boolean
    engineCountersJson?: boolean
    mutableStateJson?: boolean
    hitlStateJson?: boolean
    outputsByNodeJson?: boolean
    updatedAt?: boolean
    testSuiteRunId?: boolean
    testCaseIndex?: boolean
    testCaseLabel?: boolean
    testCaseStatus?: boolean
    workItems?: boolean | Run$workItemsArgs<ExtArgs>
    executionInstances?: boolean | Run$executionInstancesArgs<ExtArgs>
    slotProjection?: boolean | Run$slotProjectionArgs<ExtArgs>
    testSuiteRun?: boolean | Run$testSuiteRunArgs<ExtArgs>
    testAssertions?: boolean | Run$testAssertionsArgs<ExtArgs>
    workflowSnapshot?: boolean | Run$workflowSnapshotArgs<ExtArgs>
    _count?: boolean | RunCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["run"]>

  export type RunSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    status?: boolean
    revision?: boolean
    parentJson?: boolean
    executionOptionsJson?: boolean
    controlJson?: boolean
    workflowSnapshotJson?: boolean
    workflowSnapshotId?: boolean
    policySnapshotJson?: boolean
    engineCountersJson?: boolean
    mutableStateJson?: boolean
    hitlStateJson?: boolean
    outputsByNodeJson?: boolean
    updatedAt?: boolean
    testSuiteRunId?: boolean
    testCaseIndex?: boolean
    testCaseLabel?: boolean
    testCaseStatus?: boolean
    testSuiteRun?: boolean | Run$testSuiteRunArgs<ExtArgs>
    workflowSnapshot?: boolean | Run$workflowSnapshotArgs<ExtArgs>
  }, ExtArgs["result"]["run"]>

  export type RunSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    status?: boolean
    revision?: boolean
    parentJson?: boolean
    executionOptionsJson?: boolean
    controlJson?: boolean
    workflowSnapshotJson?: boolean
    workflowSnapshotId?: boolean
    policySnapshotJson?: boolean
    engineCountersJson?: boolean
    mutableStateJson?: boolean
    hitlStateJson?: boolean
    outputsByNodeJson?: boolean
    updatedAt?: boolean
    testSuiteRunId?: boolean
    testCaseIndex?: boolean
    testCaseLabel?: boolean
    testCaseStatus?: boolean
    testSuiteRun?: boolean | Run$testSuiteRunArgs<ExtArgs>
    workflowSnapshot?: boolean | Run$workflowSnapshotArgs<ExtArgs>
  }, ExtArgs["result"]["run"]>

  export type RunSelectScalar = {
    runId?: boolean
    workflowId?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    status?: boolean
    revision?: boolean
    parentJson?: boolean
    executionOptionsJson?: boolean
    controlJson?: boolean
    workflowSnapshotJson?: boolean
    workflowSnapshotId?: boolean
    policySnapshotJson?: boolean
    engineCountersJson?: boolean
    mutableStateJson?: boolean
    hitlStateJson?: boolean
    outputsByNodeJson?: boolean
    updatedAt?: boolean
    testSuiteRunId?: boolean
    testCaseIndex?: boolean
    testCaseLabel?: boolean
    testCaseStatus?: boolean
  }

  export type RunOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"runId" | "workflowId" | "startedAt" | "finishedAt" | "status" | "revision" | "parentJson" | "executionOptionsJson" | "controlJson" | "workflowSnapshotJson" | "workflowSnapshotId" | "policySnapshotJson" | "engineCountersJson" | "mutableStateJson" | "hitlStateJson" | "outputsByNodeJson" | "updatedAt" | "testSuiteRunId" | "testCaseIndex" | "testCaseLabel" | "testCaseStatus", ExtArgs["result"]["run"]>
  export type RunInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    workItems?: boolean | Run$workItemsArgs<ExtArgs>
    executionInstances?: boolean | Run$executionInstancesArgs<ExtArgs>
    slotProjection?: boolean | Run$slotProjectionArgs<ExtArgs>
    testSuiteRun?: boolean | Run$testSuiteRunArgs<ExtArgs>
    testAssertions?: boolean | Run$testAssertionsArgs<ExtArgs>
    workflowSnapshot?: boolean | Run$workflowSnapshotArgs<ExtArgs>
    _count?: boolean | RunCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type RunIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    testSuiteRun?: boolean | Run$testSuiteRunArgs<ExtArgs>
    workflowSnapshot?: boolean | Run$workflowSnapshotArgs<ExtArgs>
  }
  export type RunIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    testSuiteRun?: boolean | Run$testSuiteRunArgs<ExtArgs>
    workflowSnapshot?: boolean | Run$workflowSnapshotArgs<ExtArgs>
  }

  export type $RunPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Run"
    objects: {
      workItems: Prisma.$RunWorkItemPayload<ExtArgs>[]
      executionInstances: Prisma.$ExecutionInstancePayload<ExtArgs>[]
      slotProjection: Prisma.$RunSlotProjectionPayload<ExtArgs> | null
      testSuiteRun: Prisma.$TestSuiteRunPayload<ExtArgs> | null
      testAssertions: Prisma.$TestAssertionPayload<ExtArgs>[]
      workflowSnapshot: Prisma.$WorkflowSnapshotPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      runId: string
      workflowId: string
      startedAt: string
      finishedAt: string | null
      status: string
      revision: number
      parentJson: string | null
      executionOptionsJson: string | null
      controlJson: string | null
      workflowSnapshotJson: string | null
      workflowSnapshotId: string | null
      policySnapshotJson: string | null
      engineCountersJson: string | null
      mutableStateJson: string | null
      hitlStateJson: string | null
      outputsByNodeJson: string
      updatedAt: string
      testSuiteRunId: string | null
      testCaseIndex: number | null
      testCaseLabel: string | null
      testCaseStatus: string | null
    }, ExtArgs["result"]["run"]>
    composites: {}
  }

  type RunGetPayload<S extends boolean | null | undefined | RunDefaultArgs> = $Result.GetResult<Prisma.$RunPayload, S>

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

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

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

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

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

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

    /**
     * Create a Run.
     * @param {RunCreateArgs} args - Arguments to create a Run.
     * @example
     * // Create one Run
     * const Run = await prisma.run.create({
     *   data: {
     *     // ... data to create a Run
     *   }
     * })
     * 
     */
    create<T extends RunCreateArgs>(args: SelectSubset<T, RunCreateArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Runs and returns the data saved in the database.
     * @param {RunCreateManyAndReturnArgs} args - Arguments to create many Runs.
     * @example
     * // Create many Runs
     * const run = await prisma.run.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Runs and only return the `runId`
     * const runWithRunIdOnly = await prisma.run.createManyAndReturn({
     *   select: { runId: 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 RunCreateManyAndReturnArgs>(args?: SelectSubset<T, RunCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Run.
     * @param {RunDeleteArgs} args - Arguments to delete one Run.
     * @example
     * // Delete one Run
     * const Run = await prisma.run.delete({
     *   where: {
     *     // ... filter to delete one Run
     *   }
     * })
     * 
     */
    delete<T extends RunDeleteArgs>(args: SelectSubset<T, RunDeleteArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Run.
   * 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__RunClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    workItems<T extends Run$workItemsArgs<ExtArgs> = {}>(args?: Subset<T, Run$workItemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    executionInstances<T extends Run$executionInstancesArgs<ExtArgs> = {}>(args?: Subset<T, Run$executionInstancesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    slotProjection<T extends Run$slotProjectionArgs<ExtArgs> = {}>(args?: Subset<T, Run$slotProjectionArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    testSuiteRun<T extends Run$testSuiteRunArgs<ExtArgs> = {}>(args?: Subset<T, Run$testSuiteRunArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    testAssertions<T extends Run$testAssertionsArgs<ExtArgs> = {}>(args?: Subset<T, Run$testAssertionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    workflowSnapshot<T extends Run$workflowSnapshotArgs<ExtArgs> = {}>(args?: Subset<T, Run$workflowSnapshotArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Run model
   */
  interface RunFieldRefs {
    readonly runId: FieldRef<"Run", 'String'>
    readonly workflowId: FieldRef<"Run", 'String'>
    readonly startedAt: FieldRef<"Run", 'String'>
    readonly finishedAt: FieldRef<"Run", 'String'>
    readonly status: FieldRef<"Run", 'String'>
    readonly revision: FieldRef<"Run", 'Int'>
    readonly parentJson: FieldRef<"Run", 'String'>
    readonly executionOptionsJson: FieldRef<"Run", 'String'>
    readonly controlJson: FieldRef<"Run", 'String'>
    readonly workflowSnapshotJson: FieldRef<"Run", 'String'>
    readonly workflowSnapshotId: FieldRef<"Run", 'String'>
    readonly policySnapshotJson: FieldRef<"Run", 'String'>
    readonly engineCountersJson: FieldRef<"Run", 'String'>
    readonly mutableStateJson: FieldRef<"Run", 'String'>
    readonly hitlStateJson: FieldRef<"Run", 'String'>
    readonly outputsByNodeJson: FieldRef<"Run", 'String'>
    readonly updatedAt: FieldRef<"Run", 'String'>
    readonly testSuiteRunId: FieldRef<"Run", 'String'>
    readonly testCaseIndex: FieldRef<"Run", 'Int'>
    readonly testCaseLabel: FieldRef<"Run", 'String'>
    readonly testCaseStatus: FieldRef<"Run", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Run findUnique
   */
  export type RunFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * Filter, which Run to fetch.
     */
    where: RunWhereUniqueInput
  }

  /**
   * Run findUniqueOrThrow
   */
  export type RunFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * Filter, which Run to fetch.
     */
    where: RunWhereUniqueInput
  }

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

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

  /**
   * Run findMany
   */
  export type RunFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * Filter, which Runs to fetch.
     */
    where?: RunWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Runs to fetch.
     */
    orderBy?: RunOrderByWithRelationInput | RunOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Runs.
     */
    cursor?: RunWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Runs 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` Runs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Runs.
     */
    distinct?: RunScalarFieldEnum | RunScalarFieldEnum[]
  }

  /**
   * Run create
   */
  export type RunCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * The data needed to create a Run.
     */
    data: XOR<RunCreateInput, RunUncheckedCreateInput>
  }

  /**
   * Run createMany
   */
  export type RunCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Runs.
     */
    data: RunCreateManyInput | RunCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Run createManyAndReturn
   */
  export type RunCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * The data used to create many Runs.
     */
    data: RunCreateManyInput | RunCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Run update
   */
  export type RunUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * The data needed to update a Run.
     */
    data: XOR<RunUpdateInput, RunUncheckedUpdateInput>
    /**
     * Choose, which Run to update.
     */
    where: RunWhereUniqueInput
  }

  /**
   * Run updateMany
   */
  export type RunUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Runs.
     */
    data: XOR<RunUpdateManyMutationInput, RunUncheckedUpdateManyInput>
    /**
     * Filter which Runs to update
     */
    where?: RunWhereInput
    /**
     * Limit how many Runs to update.
     */
    limit?: number
  }

  /**
   * Run updateManyAndReturn
   */
  export type RunUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * The data used to update Runs.
     */
    data: XOR<RunUpdateManyMutationInput, RunUncheckedUpdateManyInput>
    /**
     * Filter which Runs to update
     */
    where?: RunWhereInput
    /**
     * Limit how many Runs to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Run upsert
   */
  export type RunUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * The filter to search for the Run to update in case it exists.
     */
    where: RunWhereUniqueInput
    /**
     * In case the Run found by the `where` argument doesn't exist, create a new Run with this data.
     */
    create: XOR<RunCreateInput, RunUncheckedCreateInput>
    /**
     * In case the Run was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RunUpdateInput, RunUncheckedUpdateInput>
  }

  /**
   * Run delete
   */
  export type RunDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    /**
     * Filter which Run to delete.
     */
    where: RunWhereUniqueInput
  }

  /**
   * Run deleteMany
   */
  export type RunDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Runs to delete
     */
    where?: RunWhereInput
    /**
     * Limit how many Runs to delete.
     */
    limit?: number
  }

  /**
   * Run.workItems
   */
  export type Run$workItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    where?: RunWorkItemWhereInput
    orderBy?: RunWorkItemOrderByWithRelationInput | RunWorkItemOrderByWithRelationInput[]
    cursor?: RunWorkItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RunWorkItemScalarFieldEnum | RunWorkItemScalarFieldEnum[]
  }

  /**
   * Run.executionInstances
   */
  export type Run$executionInstancesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    where?: ExecutionInstanceWhereInput
    orderBy?: ExecutionInstanceOrderByWithRelationInput | ExecutionInstanceOrderByWithRelationInput[]
    cursor?: ExecutionInstanceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ExecutionInstanceScalarFieldEnum | ExecutionInstanceScalarFieldEnum[]
  }

  /**
   * Run.slotProjection
   */
  export type Run$slotProjectionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    where?: RunSlotProjectionWhereInput
  }

  /**
   * Run.testSuiteRun
   */
  export type Run$testSuiteRunArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    where?: TestSuiteRunWhereInput
  }

  /**
   * Run.testAssertions
   */
  export type Run$testAssertionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    where?: TestAssertionWhereInput
    orderBy?: TestAssertionOrderByWithRelationInput | TestAssertionOrderByWithRelationInput[]
    cursor?: TestAssertionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TestAssertionScalarFieldEnum | TestAssertionScalarFieldEnum[]
  }

  /**
   * Run.workflowSnapshot
   */
  export type Run$workflowSnapshotArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    where?: WorkflowSnapshotWhereInput
  }

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


  /**
   * Model RunWorkItem
   */

  export type AggregateRunWorkItem = {
    _count: RunWorkItemCountAggregateOutputType | null
    _avg: RunWorkItemAvgAggregateOutputType | null
    _sum: RunWorkItemSumAggregateOutputType | null
    _min: RunWorkItemMinAggregateOutputType | null
    _max: RunWorkItemMaxAggregateOutputType | null
  }

  export type RunWorkItemAvgAggregateOutputType = {
    itemsIn: number | null
  }

  export type RunWorkItemSumAggregateOutputType = {
    itemsIn: number | null
  }

  export type RunWorkItemMinAggregateOutputType = {
    workItemId: string | null
    runId: string | null
    workflowId: string | null
    status: string | null
    targetNodeId: string | null
    batchId: string | null
    queueName: string | null
    claimToken: string | null
    claimedBy: string | null
    claimedAt: string | null
    availableAt: string | null
    enqueuedAt: string | null
    completedAt: string | null
    failedAt: string | null
    sourceInstanceId: string | null
    parentInstanceId: string | null
    itemsIn: number | null
    inputsByPortJson: string | null
    errorJson: string | null
  }

  export type RunWorkItemMaxAggregateOutputType = {
    workItemId: string | null
    runId: string | null
    workflowId: string | null
    status: string | null
    targetNodeId: string | null
    batchId: string | null
    queueName: string | null
    claimToken: string | null
    claimedBy: string | null
    claimedAt: string | null
    availableAt: string | null
    enqueuedAt: string | null
    completedAt: string | null
    failedAt: string | null
    sourceInstanceId: string | null
    parentInstanceId: string | null
    itemsIn: number | null
    inputsByPortJson: string | null
    errorJson: string | null
  }

  export type RunWorkItemCountAggregateOutputType = {
    workItemId: number
    runId: number
    workflowId: number
    status: number
    targetNodeId: number
    batchId: number
    queueName: number
    claimToken: number
    claimedBy: number
    claimedAt: number
    availableAt: number
    enqueuedAt: number
    completedAt: number
    failedAt: number
    sourceInstanceId: number
    parentInstanceId: number
    itemsIn: number
    inputsByPortJson: number
    errorJson: number
    _all: number
  }


  export type RunWorkItemAvgAggregateInputType = {
    itemsIn?: true
  }

  export type RunWorkItemSumAggregateInputType = {
    itemsIn?: true
  }

  export type RunWorkItemMinAggregateInputType = {
    workItemId?: true
    runId?: true
    workflowId?: true
    status?: true
    targetNodeId?: true
    batchId?: true
    queueName?: true
    claimToken?: true
    claimedBy?: true
    claimedAt?: true
    availableAt?: true
    enqueuedAt?: true
    completedAt?: true
    failedAt?: true
    sourceInstanceId?: true
    parentInstanceId?: true
    itemsIn?: true
    inputsByPortJson?: true
    errorJson?: true
  }

  export type RunWorkItemMaxAggregateInputType = {
    workItemId?: true
    runId?: true
    workflowId?: true
    status?: true
    targetNodeId?: true
    batchId?: true
    queueName?: true
    claimToken?: true
    claimedBy?: true
    claimedAt?: true
    availableAt?: true
    enqueuedAt?: true
    completedAt?: true
    failedAt?: true
    sourceInstanceId?: true
    parentInstanceId?: true
    itemsIn?: true
    inputsByPortJson?: true
    errorJson?: true
  }

  export type RunWorkItemCountAggregateInputType = {
    workItemId?: true
    runId?: true
    workflowId?: true
    status?: true
    targetNodeId?: true
    batchId?: true
    queueName?: true
    claimToken?: true
    claimedBy?: true
    claimedAt?: true
    availableAt?: true
    enqueuedAt?: true
    completedAt?: true
    failedAt?: true
    sourceInstanceId?: true
    parentInstanceId?: true
    itemsIn?: true
    inputsByPortJson?: true
    errorJson?: true
    _all?: true
  }

  export type RunWorkItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RunWorkItem to aggregate.
     */
    where?: RunWorkItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of RunWorkItems to fetch.
     */
    orderBy?: RunWorkItemOrderByWithRelationInput | RunWorkItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: RunWorkItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` RunWorkItems 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` RunWorkItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned RunWorkItems
    **/
    _count?: true | RunWorkItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: RunWorkItemAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: RunWorkItemSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: RunWorkItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: RunWorkItemMaxAggregateInputType
  }

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




  export type RunWorkItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunWorkItemWhereInput
    orderBy?: RunWorkItemOrderByWithAggregationInput | RunWorkItemOrderByWithAggregationInput[]
    by: RunWorkItemScalarFieldEnum[] | RunWorkItemScalarFieldEnum
    having?: RunWorkItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RunWorkItemCountAggregateInputType | true
    _avg?: RunWorkItemAvgAggregateInputType
    _sum?: RunWorkItemSumAggregateInputType
    _min?: RunWorkItemMinAggregateInputType
    _max?: RunWorkItemMaxAggregateInputType
  }

  export type RunWorkItemGroupByOutputType = {
    workItemId: string
    runId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName: string | null
    claimToken: string | null
    claimedBy: string | null
    claimedAt: string | null
    availableAt: string
    enqueuedAt: string
    completedAt: string | null
    failedAt: string | null
    sourceInstanceId: string | null
    parentInstanceId: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson: string | null
    _count: RunWorkItemCountAggregateOutputType | null
    _avg: RunWorkItemAvgAggregateOutputType | null
    _sum: RunWorkItemSumAggregateOutputType | null
    _min: RunWorkItemMinAggregateOutputType | null
    _max: RunWorkItemMaxAggregateOutputType | null
  }

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


  export type RunWorkItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workItemId?: boolean
    runId?: boolean
    workflowId?: boolean
    status?: boolean
    targetNodeId?: boolean
    batchId?: boolean
    queueName?: boolean
    claimToken?: boolean
    claimedBy?: boolean
    claimedAt?: boolean
    availableAt?: boolean
    enqueuedAt?: boolean
    completedAt?: boolean
    failedAt?: boolean
    sourceInstanceId?: boolean
    parentInstanceId?: boolean
    itemsIn?: boolean
    inputsByPortJson?: boolean
    errorJson?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["runWorkItem"]>

  export type RunWorkItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workItemId?: boolean
    runId?: boolean
    workflowId?: boolean
    status?: boolean
    targetNodeId?: boolean
    batchId?: boolean
    queueName?: boolean
    claimToken?: boolean
    claimedBy?: boolean
    claimedAt?: boolean
    availableAt?: boolean
    enqueuedAt?: boolean
    completedAt?: boolean
    failedAt?: boolean
    sourceInstanceId?: boolean
    parentInstanceId?: boolean
    itemsIn?: boolean
    inputsByPortJson?: boolean
    errorJson?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["runWorkItem"]>

  export type RunWorkItemSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workItemId?: boolean
    runId?: boolean
    workflowId?: boolean
    status?: boolean
    targetNodeId?: boolean
    batchId?: boolean
    queueName?: boolean
    claimToken?: boolean
    claimedBy?: boolean
    claimedAt?: boolean
    availableAt?: boolean
    enqueuedAt?: boolean
    completedAt?: boolean
    failedAt?: boolean
    sourceInstanceId?: boolean
    parentInstanceId?: boolean
    itemsIn?: boolean
    inputsByPortJson?: boolean
    errorJson?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["runWorkItem"]>

  export type RunWorkItemSelectScalar = {
    workItemId?: boolean
    runId?: boolean
    workflowId?: boolean
    status?: boolean
    targetNodeId?: boolean
    batchId?: boolean
    queueName?: boolean
    claimToken?: boolean
    claimedBy?: boolean
    claimedAt?: boolean
    availableAt?: boolean
    enqueuedAt?: boolean
    completedAt?: boolean
    failedAt?: boolean
    sourceInstanceId?: boolean
    parentInstanceId?: boolean
    itemsIn?: boolean
    inputsByPortJson?: boolean
    errorJson?: boolean
  }

  export type RunWorkItemOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"workItemId" | "runId" | "workflowId" | "status" | "targetNodeId" | "batchId" | "queueName" | "claimToken" | "claimedBy" | "claimedAt" | "availableAt" | "enqueuedAt" | "completedAt" | "failedAt" | "sourceInstanceId" | "parentInstanceId" | "itemsIn" | "inputsByPortJson" | "errorJson", ExtArgs["result"]["runWorkItem"]>
  export type RunWorkItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }
  export type RunWorkItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }
  export type RunWorkItemIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }

  export type $RunWorkItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "RunWorkItem"
    objects: {
      run: Prisma.$RunPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      workItemId: string
      runId: string
      workflowId: string
      status: string
      targetNodeId: string
      batchId: string
      queueName: string | null
      claimToken: string | null
      claimedBy: string | null
      claimedAt: string | null
      availableAt: string
      enqueuedAt: string
      completedAt: string | null
      failedAt: string | null
      sourceInstanceId: string | null
      parentInstanceId: string | null
      itemsIn: number
      inputsByPortJson: string
      errorJson: string | null
    }, ExtArgs["result"]["runWorkItem"]>
    composites: {}
  }

  type RunWorkItemGetPayload<S extends boolean | null | undefined | RunWorkItemDefaultArgs> = $Result.GetResult<Prisma.$RunWorkItemPayload, S>

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

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

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

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

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

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

    /**
     * Create a RunWorkItem.
     * @param {RunWorkItemCreateArgs} args - Arguments to create a RunWorkItem.
     * @example
     * // Create one RunWorkItem
     * const RunWorkItem = await prisma.runWorkItem.create({
     *   data: {
     *     // ... data to create a RunWorkItem
     *   }
     * })
     * 
     */
    create<T extends RunWorkItemCreateArgs>(args: SelectSubset<T, RunWorkItemCreateArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many RunWorkItems and returns the data saved in the database.
     * @param {RunWorkItemCreateManyAndReturnArgs} args - Arguments to create many RunWorkItems.
     * @example
     * // Create many RunWorkItems
     * const runWorkItem = await prisma.runWorkItem.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many RunWorkItems and only return the `workItemId`
     * const runWorkItemWithWorkItemIdOnly = await prisma.runWorkItem.createManyAndReturn({
     *   select: { workItemId: 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 RunWorkItemCreateManyAndReturnArgs>(args?: SelectSubset<T, RunWorkItemCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a RunWorkItem.
     * @param {RunWorkItemDeleteArgs} args - Arguments to delete one RunWorkItem.
     * @example
     * // Delete one RunWorkItem
     * const RunWorkItem = await prisma.runWorkItem.delete({
     *   where: {
     *     // ... filter to delete one RunWorkItem
     *   }
     * })
     * 
     */
    delete<T extends RunWorkItemDeleteArgs>(args: SelectSubset<T, RunWorkItemDeleteArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the RunWorkItem model
   */
  interface RunWorkItemFieldRefs {
    readonly workItemId: FieldRef<"RunWorkItem", 'String'>
    readonly runId: FieldRef<"RunWorkItem", 'String'>
    readonly workflowId: FieldRef<"RunWorkItem", 'String'>
    readonly status: FieldRef<"RunWorkItem", 'String'>
    readonly targetNodeId: FieldRef<"RunWorkItem", 'String'>
    readonly batchId: FieldRef<"RunWorkItem", 'String'>
    readonly queueName: FieldRef<"RunWorkItem", 'String'>
    readonly claimToken: FieldRef<"RunWorkItem", 'String'>
    readonly claimedBy: FieldRef<"RunWorkItem", 'String'>
    readonly claimedAt: FieldRef<"RunWorkItem", 'String'>
    readonly availableAt: FieldRef<"RunWorkItem", 'String'>
    readonly enqueuedAt: FieldRef<"RunWorkItem", 'String'>
    readonly completedAt: FieldRef<"RunWorkItem", 'String'>
    readonly failedAt: FieldRef<"RunWorkItem", 'String'>
    readonly sourceInstanceId: FieldRef<"RunWorkItem", 'String'>
    readonly parentInstanceId: FieldRef<"RunWorkItem", 'String'>
    readonly itemsIn: FieldRef<"RunWorkItem", 'Int'>
    readonly inputsByPortJson: FieldRef<"RunWorkItem", 'String'>
    readonly errorJson: FieldRef<"RunWorkItem", 'String'>
  }
    

  // Custom InputTypes
  /**
   * RunWorkItem findUnique
   */
  export type RunWorkItemFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * Filter, which RunWorkItem to fetch.
     */
    where: RunWorkItemWhereUniqueInput
  }

  /**
   * RunWorkItem findUniqueOrThrow
   */
  export type RunWorkItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * Filter, which RunWorkItem to fetch.
     */
    where: RunWorkItemWhereUniqueInput
  }

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

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

  /**
   * RunWorkItem findMany
   */
  export type RunWorkItemFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * Filter, which RunWorkItems to fetch.
     */
    where?: RunWorkItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of RunWorkItems to fetch.
     */
    orderBy?: RunWorkItemOrderByWithRelationInput | RunWorkItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing RunWorkItems.
     */
    cursor?: RunWorkItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` RunWorkItems 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` RunWorkItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of RunWorkItems.
     */
    distinct?: RunWorkItemScalarFieldEnum | RunWorkItemScalarFieldEnum[]
  }

  /**
   * RunWorkItem create
   */
  export type RunWorkItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * The data needed to create a RunWorkItem.
     */
    data: XOR<RunWorkItemCreateInput, RunWorkItemUncheckedCreateInput>
  }

  /**
   * RunWorkItem createMany
   */
  export type RunWorkItemCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many RunWorkItems.
     */
    data: RunWorkItemCreateManyInput | RunWorkItemCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * RunWorkItem createManyAndReturn
   */
  export type RunWorkItemCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * The data used to create many RunWorkItems.
     */
    data: RunWorkItemCreateManyInput | RunWorkItemCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * RunWorkItem update
   */
  export type RunWorkItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * The data needed to update a RunWorkItem.
     */
    data: XOR<RunWorkItemUpdateInput, RunWorkItemUncheckedUpdateInput>
    /**
     * Choose, which RunWorkItem to update.
     */
    where: RunWorkItemWhereUniqueInput
  }

  /**
   * RunWorkItem updateMany
   */
  export type RunWorkItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update RunWorkItems.
     */
    data: XOR<RunWorkItemUpdateManyMutationInput, RunWorkItemUncheckedUpdateManyInput>
    /**
     * Filter which RunWorkItems to update
     */
    where?: RunWorkItemWhereInput
    /**
     * Limit how many RunWorkItems to update.
     */
    limit?: number
  }

  /**
   * RunWorkItem updateManyAndReturn
   */
  export type RunWorkItemUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * The data used to update RunWorkItems.
     */
    data: XOR<RunWorkItemUpdateManyMutationInput, RunWorkItemUncheckedUpdateManyInput>
    /**
     * Filter which RunWorkItems to update
     */
    where?: RunWorkItemWhereInput
    /**
     * Limit how many RunWorkItems to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * RunWorkItem upsert
   */
  export type RunWorkItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * The filter to search for the RunWorkItem to update in case it exists.
     */
    where: RunWorkItemWhereUniqueInput
    /**
     * In case the RunWorkItem found by the `where` argument doesn't exist, create a new RunWorkItem with this data.
     */
    create: XOR<RunWorkItemCreateInput, RunWorkItemUncheckedCreateInput>
    /**
     * In case the RunWorkItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RunWorkItemUpdateInput, RunWorkItemUncheckedUpdateInput>
  }

  /**
   * RunWorkItem delete
   */
  export type RunWorkItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunWorkItem
     */
    select?: RunWorkItemSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunWorkItem
     */
    omit?: RunWorkItemOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunWorkItemInclude<ExtArgs> | null
    /**
     * Filter which RunWorkItem to delete.
     */
    where: RunWorkItemWhereUniqueInput
  }

  /**
   * RunWorkItem deleteMany
   */
  export type RunWorkItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RunWorkItems to delete
     */
    where?: RunWorkItemWhereInput
    /**
     * Limit how many RunWorkItems to delete.
     */
    limit?: number
  }

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


  /**
   * Model ExecutionInstance
   */

  export type AggregateExecutionInstance = {
    _count: ExecutionInstanceCountAggregateOutputType | null
    _avg: ExecutionInstanceAvgAggregateOutputType | null
    _sum: ExecutionInstanceSumAggregateOutputType | null
    _min: ExecutionInstanceMinAggregateOutputType | null
    _max: ExecutionInstanceMaxAggregateOutputType | null
  }

  export type ExecutionInstanceAvgAggregateOutputType = {
    runIndex: number | null
    itemCount: number | null
    outputItemCount: number | null
    successfulItemCount: number | null
    failedItemCount: number | null
    inputBytes: number | null
    outputBytes: number | null
    itemIndex: number | null
  }

  export type ExecutionInstanceSumAggregateOutputType = {
    runIndex: number | null
    itemCount: number | null
    outputItemCount: number | null
    successfulItemCount: number | null
    failedItemCount: number | null
    inputBytes: number | null
    outputBytes: number | null
    itemIndex: number | null
  }

  export type ExecutionInstanceMinAggregateOutputType = {
    instanceId: string | null
    runId: string | null
    workflowId: string | null
    slotNodeId: string | null
    workflowNodeId: string | null
    kind: string | null
    connectionKind: string | null
    activationId: string | null
    batchId: string | null
    runIndex: number | null
    parentInstanceId: string | null
    parentRunId: string | null
    workerClaimToken: string | null
    status: string | null
    queuedAt: string | null
    startedAt: string | null
    finishedAt: string | null
    updatedAt: string | null
    itemCount: number | null
    inputJson: string | null
    outputJson: string | null
    errorJson: string | null
    inputItemIndicesJson: string | null
    outputItemCount: number | null
    successfulItemCount: number | null
    failedItemCount: number | null
    inputStorageKind: string | null
    outputStorageKind: string | null
    inputBytes: number | null
    outputBytes: number | null
    inputPreviewJson: string | null
    outputPreviewJson: string | null
    inputPayloadRef: string | null
    outputPayloadRef: string | null
    inputTruncated: boolean | null
    outputTruncated: boolean | null
    usedPinnedOutput: boolean | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    childRunId: string | null
  }

  export type ExecutionInstanceMaxAggregateOutputType = {
    instanceId: string | null
    runId: string | null
    workflowId: string | null
    slotNodeId: string | null
    workflowNodeId: string | null
    kind: string | null
    connectionKind: string | null
    activationId: string | null
    batchId: string | null
    runIndex: number | null
    parentInstanceId: string | null
    parentRunId: string | null
    workerClaimToken: string | null
    status: string | null
    queuedAt: string | null
    startedAt: string | null
    finishedAt: string | null
    updatedAt: string | null
    itemCount: number | null
    inputJson: string | null
    outputJson: string | null
    errorJson: string | null
    inputItemIndicesJson: string | null
    outputItemCount: number | null
    successfulItemCount: number | null
    failedItemCount: number | null
    inputStorageKind: string | null
    outputStorageKind: string | null
    inputBytes: number | null
    outputBytes: number | null
    inputPreviewJson: string | null
    outputPreviewJson: string | null
    inputPayloadRef: string | null
    outputPayloadRef: string | null
    inputTruncated: boolean | null
    outputTruncated: boolean | null
    usedPinnedOutput: boolean | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    childRunId: string | null
  }

  export type ExecutionInstanceCountAggregateOutputType = {
    instanceId: number
    runId: number
    workflowId: number
    slotNodeId: number
    workflowNodeId: number
    kind: number
    connectionKind: number
    activationId: number
    batchId: number
    runIndex: number
    parentInstanceId: number
    parentRunId: number
    workerClaimToken: number
    status: number
    queuedAt: number
    startedAt: number
    finishedAt: number
    updatedAt: number
    itemCount: number
    inputJson: number
    outputJson: number
    errorJson: number
    inputItemIndicesJson: number
    outputItemCount: number
    successfulItemCount: number
    failedItemCount: number
    inputStorageKind: number
    outputStorageKind: number
    inputBytes: number
    outputBytes: number
    inputPreviewJson: number
    outputPreviewJson: number
    inputPayloadRef: number
    outputPayloadRef: number
    inputTruncated: number
    outputTruncated: number
    usedPinnedOutput: number
    iterationId: number
    itemIndex: number
    parentInvocationId: number
    childRunId: number
    _all: number
  }


  export type ExecutionInstanceAvgAggregateInputType = {
    runIndex?: true
    itemCount?: true
    outputItemCount?: true
    successfulItemCount?: true
    failedItemCount?: true
    inputBytes?: true
    outputBytes?: true
    itemIndex?: true
  }

  export type ExecutionInstanceSumAggregateInputType = {
    runIndex?: true
    itemCount?: true
    outputItemCount?: true
    successfulItemCount?: true
    failedItemCount?: true
    inputBytes?: true
    outputBytes?: true
    itemIndex?: true
  }

  export type ExecutionInstanceMinAggregateInputType = {
    instanceId?: true
    runId?: true
    workflowId?: true
    slotNodeId?: true
    workflowNodeId?: true
    kind?: true
    connectionKind?: true
    activationId?: true
    batchId?: true
    runIndex?: true
    parentInstanceId?: true
    parentRunId?: true
    workerClaimToken?: true
    status?: true
    queuedAt?: true
    startedAt?: true
    finishedAt?: true
    updatedAt?: true
    itemCount?: true
    inputJson?: true
    outputJson?: true
    errorJson?: true
    inputItemIndicesJson?: true
    outputItemCount?: true
    successfulItemCount?: true
    failedItemCount?: true
    inputStorageKind?: true
    outputStorageKind?: true
    inputBytes?: true
    outputBytes?: true
    inputPreviewJson?: true
    outputPreviewJson?: true
    inputPayloadRef?: true
    outputPayloadRef?: true
    inputTruncated?: true
    outputTruncated?: true
    usedPinnedOutput?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    childRunId?: true
  }

  export type ExecutionInstanceMaxAggregateInputType = {
    instanceId?: true
    runId?: true
    workflowId?: true
    slotNodeId?: true
    workflowNodeId?: true
    kind?: true
    connectionKind?: true
    activationId?: true
    batchId?: true
    runIndex?: true
    parentInstanceId?: true
    parentRunId?: true
    workerClaimToken?: true
    status?: true
    queuedAt?: true
    startedAt?: true
    finishedAt?: true
    updatedAt?: true
    itemCount?: true
    inputJson?: true
    outputJson?: true
    errorJson?: true
    inputItemIndicesJson?: true
    outputItemCount?: true
    successfulItemCount?: true
    failedItemCount?: true
    inputStorageKind?: true
    outputStorageKind?: true
    inputBytes?: true
    outputBytes?: true
    inputPreviewJson?: true
    outputPreviewJson?: true
    inputPayloadRef?: true
    outputPayloadRef?: true
    inputTruncated?: true
    outputTruncated?: true
    usedPinnedOutput?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    childRunId?: true
  }

  export type ExecutionInstanceCountAggregateInputType = {
    instanceId?: true
    runId?: true
    workflowId?: true
    slotNodeId?: true
    workflowNodeId?: true
    kind?: true
    connectionKind?: true
    activationId?: true
    batchId?: true
    runIndex?: true
    parentInstanceId?: true
    parentRunId?: true
    workerClaimToken?: true
    status?: true
    queuedAt?: true
    startedAt?: true
    finishedAt?: true
    updatedAt?: true
    itemCount?: true
    inputJson?: true
    outputJson?: true
    errorJson?: true
    inputItemIndicesJson?: true
    outputItemCount?: true
    successfulItemCount?: true
    failedItemCount?: true
    inputStorageKind?: true
    outputStorageKind?: true
    inputBytes?: true
    outputBytes?: true
    inputPreviewJson?: true
    outputPreviewJson?: true
    inputPayloadRef?: true
    outputPayloadRef?: true
    inputTruncated?: true
    outputTruncated?: true
    usedPinnedOutput?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    childRunId?: true
    _all?: true
  }

  export type ExecutionInstanceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExecutionInstance to aggregate.
     */
    where?: ExecutionInstanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExecutionInstances to fetch.
     */
    orderBy?: ExecutionInstanceOrderByWithRelationInput | ExecutionInstanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExecutionInstanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExecutionInstances 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` ExecutionInstances.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ExecutionInstances
    **/
    _count?: true | ExecutionInstanceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExecutionInstanceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExecutionInstanceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExecutionInstanceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExecutionInstanceMaxAggregateInputType
  }

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




  export type ExecutionInstanceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExecutionInstanceWhereInput
    orderBy?: ExecutionInstanceOrderByWithAggregationInput | ExecutionInstanceOrderByWithAggregationInput[]
    by: ExecutionInstanceScalarFieldEnum[] | ExecutionInstanceScalarFieldEnum
    having?: ExecutionInstanceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExecutionInstanceCountAggregateInputType | true
    _avg?: ExecutionInstanceAvgAggregateInputType
    _sum?: ExecutionInstanceSumAggregateInputType
    _min?: ExecutionInstanceMinAggregateInputType
    _max?: ExecutionInstanceMaxAggregateInputType
  }

  export type ExecutionInstanceGroupByOutputType = {
    instanceId: string
    runId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind: string | null
    activationId: string | null
    batchId: string
    runIndex: number
    parentInstanceId: string | null
    parentRunId: string | null
    workerClaimToken: string | null
    status: string
    queuedAt: string | null
    startedAt: string | null
    finishedAt: string | null
    updatedAt: string
    itemCount: number
    inputJson: string | null
    outputJson: string | null
    errorJson: string | null
    inputItemIndicesJson: string | null
    outputItemCount: number | null
    successfulItemCount: number | null
    failedItemCount: number | null
    inputStorageKind: string | null
    outputStorageKind: string | null
    inputBytes: number | null
    outputBytes: number | null
    inputPreviewJson: string | null
    outputPreviewJson: string | null
    inputPayloadRef: string | null
    outputPayloadRef: string | null
    inputTruncated: boolean | null
    outputTruncated: boolean | null
    usedPinnedOutput: boolean | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    childRunId: string | null
    _count: ExecutionInstanceCountAggregateOutputType | null
    _avg: ExecutionInstanceAvgAggregateOutputType | null
    _sum: ExecutionInstanceSumAggregateOutputType | null
    _min: ExecutionInstanceMinAggregateOutputType | null
    _max: ExecutionInstanceMaxAggregateOutputType | null
  }

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


  export type ExecutionInstanceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    runId?: boolean
    workflowId?: boolean
    slotNodeId?: boolean
    workflowNodeId?: boolean
    kind?: boolean
    connectionKind?: boolean
    activationId?: boolean
    batchId?: boolean
    runIndex?: boolean
    parentInstanceId?: boolean
    parentRunId?: boolean
    workerClaimToken?: boolean
    status?: boolean
    queuedAt?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    updatedAt?: boolean
    itemCount?: boolean
    inputJson?: boolean
    outputJson?: boolean
    errorJson?: boolean
    inputItemIndicesJson?: boolean
    outputItemCount?: boolean
    successfulItemCount?: boolean
    failedItemCount?: boolean
    inputStorageKind?: boolean
    outputStorageKind?: boolean
    inputBytes?: boolean
    outputBytes?: boolean
    inputPreviewJson?: boolean
    outputPreviewJson?: boolean
    inputPayloadRef?: boolean
    outputPayloadRef?: boolean
    inputTruncated?: boolean
    outputTruncated?: boolean
    usedPinnedOutput?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    childRunId?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["executionInstance"]>

  export type ExecutionInstanceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    runId?: boolean
    workflowId?: boolean
    slotNodeId?: boolean
    workflowNodeId?: boolean
    kind?: boolean
    connectionKind?: boolean
    activationId?: boolean
    batchId?: boolean
    runIndex?: boolean
    parentInstanceId?: boolean
    parentRunId?: boolean
    workerClaimToken?: boolean
    status?: boolean
    queuedAt?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    updatedAt?: boolean
    itemCount?: boolean
    inputJson?: boolean
    outputJson?: boolean
    errorJson?: boolean
    inputItemIndicesJson?: boolean
    outputItemCount?: boolean
    successfulItemCount?: boolean
    failedItemCount?: boolean
    inputStorageKind?: boolean
    outputStorageKind?: boolean
    inputBytes?: boolean
    outputBytes?: boolean
    inputPreviewJson?: boolean
    outputPreviewJson?: boolean
    inputPayloadRef?: boolean
    outputPayloadRef?: boolean
    inputTruncated?: boolean
    outputTruncated?: boolean
    usedPinnedOutput?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    childRunId?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["executionInstance"]>

  export type ExecutionInstanceSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    runId?: boolean
    workflowId?: boolean
    slotNodeId?: boolean
    workflowNodeId?: boolean
    kind?: boolean
    connectionKind?: boolean
    activationId?: boolean
    batchId?: boolean
    runIndex?: boolean
    parentInstanceId?: boolean
    parentRunId?: boolean
    workerClaimToken?: boolean
    status?: boolean
    queuedAt?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    updatedAt?: boolean
    itemCount?: boolean
    inputJson?: boolean
    outputJson?: boolean
    errorJson?: boolean
    inputItemIndicesJson?: boolean
    outputItemCount?: boolean
    successfulItemCount?: boolean
    failedItemCount?: boolean
    inputStorageKind?: boolean
    outputStorageKind?: boolean
    inputBytes?: boolean
    outputBytes?: boolean
    inputPreviewJson?: boolean
    outputPreviewJson?: boolean
    inputPayloadRef?: boolean
    outputPayloadRef?: boolean
    inputTruncated?: boolean
    outputTruncated?: boolean
    usedPinnedOutput?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    childRunId?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["executionInstance"]>

  export type ExecutionInstanceSelectScalar = {
    instanceId?: boolean
    runId?: boolean
    workflowId?: boolean
    slotNodeId?: boolean
    workflowNodeId?: boolean
    kind?: boolean
    connectionKind?: boolean
    activationId?: boolean
    batchId?: boolean
    runIndex?: boolean
    parentInstanceId?: boolean
    parentRunId?: boolean
    workerClaimToken?: boolean
    status?: boolean
    queuedAt?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    updatedAt?: boolean
    itemCount?: boolean
    inputJson?: boolean
    outputJson?: boolean
    errorJson?: boolean
    inputItemIndicesJson?: boolean
    outputItemCount?: boolean
    successfulItemCount?: boolean
    failedItemCount?: boolean
    inputStorageKind?: boolean
    outputStorageKind?: boolean
    inputBytes?: boolean
    outputBytes?: boolean
    inputPreviewJson?: boolean
    outputPreviewJson?: boolean
    inputPayloadRef?: boolean
    outputPayloadRef?: boolean
    inputTruncated?: boolean
    outputTruncated?: boolean
    usedPinnedOutput?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    childRunId?: boolean
  }

  export type ExecutionInstanceOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"instanceId" | "runId" | "workflowId" | "slotNodeId" | "workflowNodeId" | "kind" | "connectionKind" | "activationId" | "batchId" | "runIndex" | "parentInstanceId" | "parentRunId" | "workerClaimToken" | "status" | "queuedAt" | "startedAt" | "finishedAt" | "updatedAt" | "itemCount" | "inputJson" | "outputJson" | "errorJson" | "inputItemIndicesJson" | "outputItemCount" | "successfulItemCount" | "failedItemCount" | "inputStorageKind" | "outputStorageKind" | "inputBytes" | "outputBytes" | "inputPreviewJson" | "outputPreviewJson" | "inputPayloadRef" | "outputPayloadRef" | "inputTruncated" | "outputTruncated" | "usedPinnedOutput" | "iterationId" | "itemIndex" | "parentInvocationId" | "childRunId", ExtArgs["result"]["executionInstance"]>
  export type ExecutionInstanceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }
  export type ExecutionInstanceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }
  export type ExecutionInstanceIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }

  export type $ExecutionInstancePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ExecutionInstance"
    objects: {
      run: Prisma.$RunPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      instanceId: string
      runId: string
      workflowId: string
      slotNodeId: string
      workflowNodeId: string
      kind: string
      connectionKind: string | null
      activationId: string | null
      batchId: string
      runIndex: number
      parentInstanceId: string | null
      parentRunId: string | null
      workerClaimToken: string | null
      status: string
      queuedAt: string | null
      startedAt: string | null
      finishedAt: string | null
      updatedAt: string
      itemCount: number
      inputJson: string | null
      outputJson: string | null
      errorJson: string | null
      inputItemIndicesJson: string | null
      outputItemCount: number | null
      successfulItemCount: number | null
      failedItemCount: number | null
      inputStorageKind: string | null
      outputStorageKind: string | null
      inputBytes: number | null
      outputBytes: number | null
      inputPreviewJson: string | null
      outputPreviewJson: string | null
      inputPayloadRef: string | null
      outputPayloadRef: string | null
      inputTruncated: boolean | null
      outputTruncated: boolean | null
      usedPinnedOutput: boolean | null
      iterationId: string | null
      itemIndex: number | null
      parentInvocationId: string | null
      childRunId: string | null
    }, ExtArgs["result"]["executionInstance"]>
    composites: {}
  }

  type ExecutionInstanceGetPayload<S extends boolean | null | undefined | ExecutionInstanceDefaultArgs> = $Result.GetResult<Prisma.$ExecutionInstancePayload, S>

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

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

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

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

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

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

    /**
     * Create a ExecutionInstance.
     * @param {ExecutionInstanceCreateArgs} args - Arguments to create a ExecutionInstance.
     * @example
     * // Create one ExecutionInstance
     * const ExecutionInstance = await prisma.executionInstance.create({
     *   data: {
     *     // ... data to create a ExecutionInstance
     *   }
     * })
     * 
     */
    create<T extends ExecutionInstanceCreateArgs>(args: SelectSubset<T, ExecutionInstanceCreateArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ExecutionInstances and returns the data saved in the database.
     * @param {ExecutionInstanceCreateManyAndReturnArgs} args - Arguments to create many ExecutionInstances.
     * @example
     * // Create many ExecutionInstances
     * const executionInstance = await prisma.executionInstance.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ExecutionInstances and only return the `instanceId`
     * const executionInstanceWithInstanceIdOnly = await prisma.executionInstance.createManyAndReturn({
     *   select: { instanceId: 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 ExecutionInstanceCreateManyAndReturnArgs>(args?: SelectSubset<T, ExecutionInstanceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ExecutionInstance.
     * @param {ExecutionInstanceDeleteArgs} args - Arguments to delete one ExecutionInstance.
     * @example
     * // Delete one ExecutionInstance
     * const ExecutionInstance = await prisma.executionInstance.delete({
     *   where: {
     *     // ... filter to delete one ExecutionInstance
     *   }
     * })
     * 
     */
    delete<T extends ExecutionInstanceDeleteArgs>(args: SelectSubset<T, ExecutionInstanceDeleteArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the ExecutionInstance model
   */
  interface ExecutionInstanceFieldRefs {
    readonly instanceId: FieldRef<"ExecutionInstance", 'String'>
    readonly runId: FieldRef<"ExecutionInstance", 'String'>
    readonly workflowId: FieldRef<"ExecutionInstance", 'String'>
    readonly slotNodeId: FieldRef<"ExecutionInstance", 'String'>
    readonly workflowNodeId: FieldRef<"ExecutionInstance", 'String'>
    readonly kind: FieldRef<"ExecutionInstance", 'String'>
    readonly connectionKind: FieldRef<"ExecutionInstance", 'String'>
    readonly activationId: FieldRef<"ExecutionInstance", 'String'>
    readonly batchId: FieldRef<"ExecutionInstance", 'String'>
    readonly runIndex: FieldRef<"ExecutionInstance", 'Int'>
    readonly parentInstanceId: FieldRef<"ExecutionInstance", 'String'>
    readonly parentRunId: FieldRef<"ExecutionInstance", 'String'>
    readonly workerClaimToken: FieldRef<"ExecutionInstance", 'String'>
    readonly status: FieldRef<"ExecutionInstance", 'String'>
    readonly queuedAt: FieldRef<"ExecutionInstance", 'String'>
    readonly startedAt: FieldRef<"ExecutionInstance", 'String'>
    readonly finishedAt: FieldRef<"ExecutionInstance", 'String'>
    readonly updatedAt: FieldRef<"ExecutionInstance", 'String'>
    readonly itemCount: FieldRef<"ExecutionInstance", 'Int'>
    readonly inputJson: FieldRef<"ExecutionInstance", 'String'>
    readonly outputJson: FieldRef<"ExecutionInstance", 'String'>
    readonly errorJson: FieldRef<"ExecutionInstance", 'String'>
    readonly inputItemIndicesJson: FieldRef<"ExecutionInstance", 'String'>
    readonly outputItemCount: FieldRef<"ExecutionInstance", 'Int'>
    readonly successfulItemCount: FieldRef<"ExecutionInstance", 'Int'>
    readonly failedItemCount: FieldRef<"ExecutionInstance", 'Int'>
    readonly inputStorageKind: FieldRef<"ExecutionInstance", 'String'>
    readonly outputStorageKind: FieldRef<"ExecutionInstance", 'String'>
    readonly inputBytes: FieldRef<"ExecutionInstance", 'Int'>
    readonly outputBytes: FieldRef<"ExecutionInstance", 'Int'>
    readonly inputPreviewJson: FieldRef<"ExecutionInstance", 'String'>
    readonly outputPreviewJson: FieldRef<"ExecutionInstance", 'String'>
    readonly inputPayloadRef: FieldRef<"ExecutionInstance", 'String'>
    readonly outputPayloadRef: FieldRef<"ExecutionInstance", 'String'>
    readonly inputTruncated: FieldRef<"ExecutionInstance", 'Boolean'>
    readonly outputTruncated: FieldRef<"ExecutionInstance", 'Boolean'>
    readonly usedPinnedOutput: FieldRef<"ExecutionInstance", 'Boolean'>
    readonly iterationId: FieldRef<"ExecutionInstance", 'String'>
    readonly itemIndex: FieldRef<"ExecutionInstance", 'Int'>
    readonly parentInvocationId: FieldRef<"ExecutionInstance", 'String'>
    readonly childRunId: FieldRef<"ExecutionInstance", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ExecutionInstance findUnique
   */
  export type ExecutionInstanceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * Filter, which ExecutionInstance to fetch.
     */
    where: ExecutionInstanceWhereUniqueInput
  }

  /**
   * ExecutionInstance findUniqueOrThrow
   */
  export type ExecutionInstanceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * Filter, which ExecutionInstance to fetch.
     */
    where: ExecutionInstanceWhereUniqueInput
  }

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

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

  /**
   * ExecutionInstance findMany
   */
  export type ExecutionInstanceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * Filter, which ExecutionInstances to fetch.
     */
    where?: ExecutionInstanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExecutionInstances to fetch.
     */
    orderBy?: ExecutionInstanceOrderByWithRelationInput | ExecutionInstanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ExecutionInstances.
     */
    cursor?: ExecutionInstanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExecutionInstances 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` ExecutionInstances.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ExecutionInstances.
     */
    distinct?: ExecutionInstanceScalarFieldEnum | ExecutionInstanceScalarFieldEnum[]
  }

  /**
   * ExecutionInstance create
   */
  export type ExecutionInstanceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * The data needed to create a ExecutionInstance.
     */
    data: XOR<ExecutionInstanceCreateInput, ExecutionInstanceUncheckedCreateInput>
  }

  /**
   * ExecutionInstance createMany
   */
  export type ExecutionInstanceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ExecutionInstances.
     */
    data: ExecutionInstanceCreateManyInput | ExecutionInstanceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ExecutionInstance createManyAndReturn
   */
  export type ExecutionInstanceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * The data used to create many ExecutionInstances.
     */
    data: ExecutionInstanceCreateManyInput | ExecutionInstanceCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ExecutionInstance update
   */
  export type ExecutionInstanceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * The data needed to update a ExecutionInstance.
     */
    data: XOR<ExecutionInstanceUpdateInput, ExecutionInstanceUncheckedUpdateInput>
    /**
     * Choose, which ExecutionInstance to update.
     */
    where: ExecutionInstanceWhereUniqueInput
  }

  /**
   * ExecutionInstance updateMany
   */
  export type ExecutionInstanceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ExecutionInstances.
     */
    data: XOR<ExecutionInstanceUpdateManyMutationInput, ExecutionInstanceUncheckedUpdateManyInput>
    /**
     * Filter which ExecutionInstances to update
     */
    where?: ExecutionInstanceWhereInput
    /**
     * Limit how many ExecutionInstances to update.
     */
    limit?: number
  }

  /**
   * ExecutionInstance updateManyAndReturn
   */
  export type ExecutionInstanceUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * The data used to update ExecutionInstances.
     */
    data: XOR<ExecutionInstanceUpdateManyMutationInput, ExecutionInstanceUncheckedUpdateManyInput>
    /**
     * Filter which ExecutionInstances to update
     */
    where?: ExecutionInstanceWhereInput
    /**
     * Limit how many ExecutionInstances to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ExecutionInstance upsert
   */
  export type ExecutionInstanceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * The filter to search for the ExecutionInstance to update in case it exists.
     */
    where: ExecutionInstanceWhereUniqueInput
    /**
     * In case the ExecutionInstance found by the `where` argument doesn't exist, create a new ExecutionInstance with this data.
     */
    create: XOR<ExecutionInstanceCreateInput, ExecutionInstanceUncheckedCreateInput>
    /**
     * In case the ExecutionInstance was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExecutionInstanceUpdateInput, ExecutionInstanceUncheckedUpdateInput>
  }

  /**
   * ExecutionInstance delete
   */
  export type ExecutionInstanceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExecutionInstance
     */
    select?: ExecutionInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ExecutionInstance
     */
    omit?: ExecutionInstanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ExecutionInstanceInclude<ExtArgs> | null
    /**
     * Filter which ExecutionInstance to delete.
     */
    where: ExecutionInstanceWhereUniqueInput
  }

  /**
   * ExecutionInstance deleteMany
   */
  export type ExecutionInstanceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExecutionInstances to delete
     */
    where?: ExecutionInstanceWhereInput
    /**
     * Limit how many ExecutionInstances to delete.
     */
    limit?: number
  }

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


  /**
   * Model RunSlotProjection
   */

  export type AggregateRunSlotProjection = {
    _count: RunSlotProjectionCountAggregateOutputType | null
    _avg: RunSlotProjectionAvgAggregateOutputType | null
    _sum: RunSlotProjectionSumAggregateOutputType | null
    _min: RunSlotProjectionMinAggregateOutputType | null
    _max: RunSlotProjectionMaxAggregateOutputType | null
  }

  export type RunSlotProjectionAvgAggregateOutputType = {
    revision: number | null
  }

  export type RunSlotProjectionSumAggregateOutputType = {
    revision: number | null
  }

  export type RunSlotProjectionMinAggregateOutputType = {
    runId: string | null
    workflowId: string | null
    revision: number | null
    updatedAt: string | null
    slotStatesJson: string | null
  }

  export type RunSlotProjectionMaxAggregateOutputType = {
    runId: string | null
    workflowId: string | null
    revision: number | null
    updatedAt: string | null
    slotStatesJson: string | null
  }

  export type RunSlotProjectionCountAggregateOutputType = {
    runId: number
    workflowId: number
    revision: number
    updatedAt: number
    slotStatesJson: number
    _all: number
  }


  export type RunSlotProjectionAvgAggregateInputType = {
    revision?: true
  }

  export type RunSlotProjectionSumAggregateInputType = {
    revision?: true
  }

  export type RunSlotProjectionMinAggregateInputType = {
    runId?: true
    workflowId?: true
    revision?: true
    updatedAt?: true
    slotStatesJson?: true
  }

  export type RunSlotProjectionMaxAggregateInputType = {
    runId?: true
    workflowId?: true
    revision?: true
    updatedAt?: true
    slotStatesJson?: true
  }

  export type RunSlotProjectionCountAggregateInputType = {
    runId?: true
    workflowId?: true
    revision?: true
    updatedAt?: true
    slotStatesJson?: true
    _all?: true
  }

  export type RunSlotProjectionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RunSlotProjection to aggregate.
     */
    where?: RunSlotProjectionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of RunSlotProjections to fetch.
     */
    orderBy?: RunSlotProjectionOrderByWithRelationInput | RunSlotProjectionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: RunSlotProjectionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` RunSlotProjections 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` RunSlotProjections.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned RunSlotProjections
    **/
    _count?: true | RunSlotProjectionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: RunSlotProjectionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: RunSlotProjectionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: RunSlotProjectionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: RunSlotProjectionMaxAggregateInputType
  }

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




  export type RunSlotProjectionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunSlotProjectionWhereInput
    orderBy?: RunSlotProjectionOrderByWithAggregationInput | RunSlotProjectionOrderByWithAggregationInput[]
    by: RunSlotProjectionScalarFieldEnum[] | RunSlotProjectionScalarFieldEnum
    having?: RunSlotProjectionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RunSlotProjectionCountAggregateInputType | true
    _avg?: RunSlotProjectionAvgAggregateInputType
    _sum?: RunSlotProjectionSumAggregateInputType
    _min?: RunSlotProjectionMinAggregateInputType
    _max?: RunSlotProjectionMaxAggregateInputType
  }

  export type RunSlotProjectionGroupByOutputType = {
    runId: string
    workflowId: string
    revision: number
    updatedAt: string
    slotStatesJson: string
    _count: RunSlotProjectionCountAggregateOutputType | null
    _avg: RunSlotProjectionAvgAggregateOutputType | null
    _sum: RunSlotProjectionSumAggregateOutputType | null
    _min: RunSlotProjectionMinAggregateOutputType | null
    _max: RunSlotProjectionMaxAggregateOutputType | null
  }

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


  export type RunSlotProjectionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    revision?: boolean
    updatedAt?: boolean
    slotStatesJson?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["runSlotProjection"]>

  export type RunSlotProjectionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    revision?: boolean
    updatedAt?: boolean
    slotStatesJson?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["runSlotProjection"]>

  export type RunSlotProjectionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    revision?: boolean
    updatedAt?: boolean
    slotStatesJson?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["runSlotProjection"]>

  export type RunSlotProjectionSelectScalar = {
    runId?: boolean
    workflowId?: boolean
    revision?: boolean
    updatedAt?: boolean
    slotStatesJson?: boolean
  }

  export type RunSlotProjectionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"runId" | "workflowId" | "revision" | "updatedAt" | "slotStatesJson", ExtArgs["result"]["runSlotProjection"]>
  export type RunSlotProjectionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }
  export type RunSlotProjectionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }
  export type RunSlotProjectionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
  }

  export type $RunSlotProjectionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "RunSlotProjection"
    objects: {
      run: Prisma.$RunPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      runId: string
      workflowId: string
      revision: number
      updatedAt: string
      slotStatesJson: string
    }, ExtArgs["result"]["runSlotProjection"]>
    composites: {}
  }

  type RunSlotProjectionGetPayload<S extends boolean | null | undefined | RunSlotProjectionDefaultArgs> = $Result.GetResult<Prisma.$RunSlotProjectionPayload, S>

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

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

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

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

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

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

    /**
     * Create a RunSlotProjection.
     * @param {RunSlotProjectionCreateArgs} args - Arguments to create a RunSlotProjection.
     * @example
     * // Create one RunSlotProjection
     * const RunSlotProjection = await prisma.runSlotProjection.create({
     *   data: {
     *     // ... data to create a RunSlotProjection
     *   }
     * })
     * 
     */
    create<T extends RunSlotProjectionCreateArgs>(args: SelectSubset<T, RunSlotProjectionCreateArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many RunSlotProjections and returns the data saved in the database.
     * @param {RunSlotProjectionCreateManyAndReturnArgs} args - Arguments to create many RunSlotProjections.
     * @example
     * // Create many RunSlotProjections
     * const runSlotProjection = await prisma.runSlotProjection.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many RunSlotProjections and only return the `runId`
     * const runSlotProjectionWithRunIdOnly = await prisma.runSlotProjection.createManyAndReturn({
     *   select: { runId: 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 RunSlotProjectionCreateManyAndReturnArgs>(args?: SelectSubset<T, RunSlotProjectionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a RunSlotProjection.
     * @param {RunSlotProjectionDeleteArgs} args - Arguments to delete one RunSlotProjection.
     * @example
     * // Delete one RunSlotProjection
     * const RunSlotProjection = await prisma.runSlotProjection.delete({
     *   where: {
     *     // ... filter to delete one RunSlotProjection
     *   }
     * })
     * 
     */
    delete<T extends RunSlotProjectionDeleteArgs>(args: SelectSubset<T, RunSlotProjectionDeleteArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the RunSlotProjection model
   */
  interface RunSlotProjectionFieldRefs {
    readonly runId: FieldRef<"RunSlotProjection", 'String'>
    readonly workflowId: FieldRef<"RunSlotProjection", 'String'>
    readonly revision: FieldRef<"RunSlotProjection", 'Int'>
    readonly updatedAt: FieldRef<"RunSlotProjection", 'String'>
    readonly slotStatesJson: FieldRef<"RunSlotProjection", 'String'>
  }
    

  // Custom InputTypes
  /**
   * RunSlotProjection findUnique
   */
  export type RunSlotProjectionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * Filter, which RunSlotProjection to fetch.
     */
    where: RunSlotProjectionWhereUniqueInput
  }

  /**
   * RunSlotProjection findUniqueOrThrow
   */
  export type RunSlotProjectionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * Filter, which RunSlotProjection to fetch.
     */
    where: RunSlotProjectionWhereUniqueInput
  }

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

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

  /**
   * RunSlotProjection findMany
   */
  export type RunSlotProjectionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * Filter, which RunSlotProjections to fetch.
     */
    where?: RunSlotProjectionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of RunSlotProjections to fetch.
     */
    orderBy?: RunSlotProjectionOrderByWithRelationInput | RunSlotProjectionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing RunSlotProjections.
     */
    cursor?: RunSlotProjectionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` RunSlotProjections 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` RunSlotProjections.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of RunSlotProjections.
     */
    distinct?: RunSlotProjectionScalarFieldEnum | RunSlotProjectionScalarFieldEnum[]
  }

  /**
   * RunSlotProjection create
   */
  export type RunSlotProjectionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * The data needed to create a RunSlotProjection.
     */
    data: XOR<RunSlotProjectionCreateInput, RunSlotProjectionUncheckedCreateInput>
  }

  /**
   * RunSlotProjection createMany
   */
  export type RunSlotProjectionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many RunSlotProjections.
     */
    data: RunSlotProjectionCreateManyInput | RunSlotProjectionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * RunSlotProjection createManyAndReturn
   */
  export type RunSlotProjectionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * The data used to create many RunSlotProjections.
     */
    data: RunSlotProjectionCreateManyInput | RunSlotProjectionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * RunSlotProjection update
   */
  export type RunSlotProjectionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * The data needed to update a RunSlotProjection.
     */
    data: XOR<RunSlotProjectionUpdateInput, RunSlotProjectionUncheckedUpdateInput>
    /**
     * Choose, which RunSlotProjection to update.
     */
    where: RunSlotProjectionWhereUniqueInput
  }

  /**
   * RunSlotProjection updateMany
   */
  export type RunSlotProjectionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update RunSlotProjections.
     */
    data: XOR<RunSlotProjectionUpdateManyMutationInput, RunSlotProjectionUncheckedUpdateManyInput>
    /**
     * Filter which RunSlotProjections to update
     */
    where?: RunSlotProjectionWhereInput
    /**
     * Limit how many RunSlotProjections to update.
     */
    limit?: number
  }

  /**
   * RunSlotProjection updateManyAndReturn
   */
  export type RunSlotProjectionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * The data used to update RunSlotProjections.
     */
    data: XOR<RunSlotProjectionUpdateManyMutationInput, RunSlotProjectionUncheckedUpdateManyInput>
    /**
     * Filter which RunSlotProjections to update
     */
    where?: RunSlotProjectionWhereInput
    /**
     * Limit how many RunSlotProjections to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * RunSlotProjection upsert
   */
  export type RunSlotProjectionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * The filter to search for the RunSlotProjection to update in case it exists.
     */
    where: RunSlotProjectionWhereUniqueInput
    /**
     * In case the RunSlotProjection found by the `where` argument doesn't exist, create a new RunSlotProjection with this data.
     */
    create: XOR<RunSlotProjectionCreateInput, RunSlotProjectionUncheckedCreateInput>
    /**
     * In case the RunSlotProjection was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RunSlotProjectionUpdateInput, RunSlotProjectionUncheckedUpdateInput>
  }

  /**
   * RunSlotProjection delete
   */
  export type RunSlotProjectionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunSlotProjection
     */
    select?: RunSlotProjectionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunSlotProjection
     */
    omit?: RunSlotProjectionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunSlotProjectionInclude<ExtArgs> | null
    /**
     * Filter which RunSlotProjection to delete.
     */
    where: RunSlotProjectionWhereUniqueInput
  }

  /**
   * RunSlotProjection deleteMany
   */
  export type RunSlotProjectionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RunSlotProjections to delete
     */
    where?: RunSlotProjectionWhereInput
    /**
     * Limit how many RunSlotProjections to delete.
     */
    limit?: number
  }

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


  /**
   * Model TestSuiteRun
   */

  export type AggregateTestSuiteRun = {
    _count: TestSuiteRunCountAggregateOutputType | null
    _avg: TestSuiteRunAvgAggregateOutputType | null
    _sum: TestSuiteRunSumAggregateOutputType | null
    _min: TestSuiteRunMinAggregateOutputType | null
    _max: TestSuiteRunMaxAggregateOutputType | null
  }

  export type TestSuiteRunAvgAggregateOutputType = {
    concurrency: number | null
    totalCases: number | null
    passedCases: number | null
    failedCases: number | null
  }

  export type TestSuiteRunSumAggregateOutputType = {
    concurrency: number | null
    totalCases: number | null
    passedCases: number | null
    failedCases: number | null
  }

  export type TestSuiteRunMinAggregateOutputType = {
    id: string | null
    workflowId: string | null
    triggerNodeId: string | null
    triggerNodeName: string | null
    status: string | null
    concurrency: number | null
    startedAt: string | null
    finishedAt: string | null
    totalCases: number | null
    passedCases: number | null
    failedCases: number | null
    nodeCoverageJson: string | null
    errorMessage: string | null
    updatedAt: string | null
  }

  export type TestSuiteRunMaxAggregateOutputType = {
    id: string | null
    workflowId: string | null
    triggerNodeId: string | null
    triggerNodeName: string | null
    status: string | null
    concurrency: number | null
    startedAt: string | null
    finishedAt: string | null
    totalCases: number | null
    passedCases: number | null
    failedCases: number | null
    nodeCoverageJson: string | null
    errorMessage: string | null
    updatedAt: string | null
  }

  export type TestSuiteRunCountAggregateOutputType = {
    id: number
    workflowId: number
    triggerNodeId: number
    triggerNodeName: number
    status: number
    concurrency: number
    startedAt: number
    finishedAt: number
    totalCases: number
    passedCases: number
    failedCases: number
    nodeCoverageJson: number
    errorMessage: number
    updatedAt: number
    _all: number
  }


  export type TestSuiteRunAvgAggregateInputType = {
    concurrency?: true
    totalCases?: true
    passedCases?: true
    failedCases?: true
  }

  export type TestSuiteRunSumAggregateInputType = {
    concurrency?: true
    totalCases?: true
    passedCases?: true
    failedCases?: true
  }

  export type TestSuiteRunMinAggregateInputType = {
    id?: true
    workflowId?: true
    triggerNodeId?: true
    triggerNodeName?: true
    status?: true
    concurrency?: true
    startedAt?: true
    finishedAt?: true
    totalCases?: true
    passedCases?: true
    failedCases?: true
    nodeCoverageJson?: true
    errorMessage?: true
    updatedAt?: true
  }

  export type TestSuiteRunMaxAggregateInputType = {
    id?: true
    workflowId?: true
    triggerNodeId?: true
    triggerNodeName?: true
    status?: true
    concurrency?: true
    startedAt?: true
    finishedAt?: true
    totalCases?: true
    passedCases?: true
    failedCases?: true
    nodeCoverageJson?: true
    errorMessage?: true
    updatedAt?: true
  }

  export type TestSuiteRunCountAggregateInputType = {
    id?: true
    workflowId?: true
    triggerNodeId?: true
    triggerNodeName?: true
    status?: true
    concurrency?: true
    startedAt?: true
    finishedAt?: true
    totalCases?: true
    passedCases?: true
    failedCases?: true
    nodeCoverageJson?: true
    errorMessage?: true
    updatedAt?: true
    _all?: true
  }

  export type TestSuiteRunAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TestSuiteRun to aggregate.
     */
    where?: TestSuiteRunWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TestSuiteRuns to fetch.
     */
    orderBy?: TestSuiteRunOrderByWithRelationInput | TestSuiteRunOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TestSuiteRunWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TestSuiteRuns 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` TestSuiteRuns.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TestSuiteRuns
    **/
    _count?: true | TestSuiteRunCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TestSuiteRunAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TestSuiteRunSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TestSuiteRunMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TestSuiteRunMaxAggregateInputType
  }

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




  export type TestSuiteRunGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TestSuiteRunWhereInput
    orderBy?: TestSuiteRunOrderByWithAggregationInput | TestSuiteRunOrderByWithAggregationInput[]
    by: TestSuiteRunScalarFieldEnum[] | TestSuiteRunScalarFieldEnum
    having?: TestSuiteRunScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TestSuiteRunCountAggregateInputType | true
    _avg?: TestSuiteRunAvgAggregateInputType
    _sum?: TestSuiteRunSumAggregateInputType
    _min?: TestSuiteRunMinAggregateInputType
    _max?: TestSuiteRunMaxAggregateInputType
  }

  export type TestSuiteRunGroupByOutputType = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt: string | null
    totalCases: number
    passedCases: number
    failedCases: number
    nodeCoverageJson: string | null
    errorMessage: string | null
    updatedAt: string
    _count: TestSuiteRunCountAggregateOutputType | null
    _avg: TestSuiteRunAvgAggregateOutputType | null
    _sum: TestSuiteRunSumAggregateOutputType | null
    _min: TestSuiteRunMinAggregateOutputType | null
    _max: TestSuiteRunMaxAggregateOutputType | null
  }

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


  export type TestSuiteRunSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    workflowId?: boolean
    triggerNodeId?: boolean
    triggerNodeName?: boolean
    status?: boolean
    concurrency?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    totalCases?: boolean
    passedCases?: boolean
    failedCases?: boolean
    nodeCoverageJson?: boolean
    errorMessage?: boolean
    updatedAt?: boolean
    runs?: boolean | TestSuiteRun$runsArgs<ExtArgs>
    assertions?: boolean | TestSuiteRun$assertionsArgs<ExtArgs>
    _count?: boolean | TestSuiteRunCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["testSuiteRun"]>

  export type TestSuiteRunSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    workflowId?: boolean
    triggerNodeId?: boolean
    triggerNodeName?: boolean
    status?: boolean
    concurrency?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    totalCases?: boolean
    passedCases?: boolean
    failedCases?: boolean
    nodeCoverageJson?: boolean
    errorMessage?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["testSuiteRun"]>

  export type TestSuiteRunSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    workflowId?: boolean
    triggerNodeId?: boolean
    triggerNodeName?: boolean
    status?: boolean
    concurrency?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    totalCases?: boolean
    passedCases?: boolean
    failedCases?: boolean
    nodeCoverageJson?: boolean
    errorMessage?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["testSuiteRun"]>

  export type TestSuiteRunSelectScalar = {
    id?: boolean
    workflowId?: boolean
    triggerNodeId?: boolean
    triggerNodeName?: boolean
    status?: boolean
    concurrency?: boolean
    startedAt?: boolean
    finishedAt?: boolean
    totalCases?: boolean
    passedCases?: boolean
    failedCases?: boolean
    nodeCoverageJson?: boolean
    errorMessage?: boolean
    updatedAt?: boolean
  }

  export type TestSuiteRunOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "workflowId" | "triggerNodeId" | "triggerNodeName" | "status" | "concurrency" | "startedAt" | "finishedAt" | "totalCases" | "passedCases" | "failedCases" | "nodeCoverageJson" | "errorMessage" | "updatedAt", ExtArgs["result"]["testSuiteRun"]>
  export type TestSuiteRunInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    runs?: boolean | TestSuiteRun$runsArgs<ExtArgs>
    assertions?: boolean | TestSuiteRun$assertionsArgs<ExtArgs>
    _count?: boolean | TestSuiteRunCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type TestSuiteRunIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type TestSuiteRunIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $TestSuiteRunPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TestSuiteRun"
    objects: {
      runs: Prisma.$RunPayload<ExtArgs>[]
      assertions: Prisma.$TestAssertionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      workflowId: string
      triggerNodeId: string
      triggerNodeName: string | null
      status: string
      concurrency: number
      startedAt: string
      finishedAt: string | null
      totalCases: number
      passedCases: number
      failedCases: number
      /**
       * Set of nodeIds executed across all child Runs in this suite (JSON array of strings).
       */
      nodeCoverageJson: string | null
      errorMessage: string | null
      updatedAt: string
    }, ExtArgs["result"]["testSuiteRun"]>
    composites: {}
  }

  type TestSuiteRunGetPayload<S extends boolean | null | undefined | TestSuiteRunDefaultArgs> = $Result.GetResult<Prisma.$TestSuiteRunPayload, S>

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

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

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

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

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

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

    /**
     * Create a TestSuiteRun.
     * @param {TestSuiteRunCreateArgs} args - Arguments to create a TestSuiteRun.
     * @example
     * // Create one TestSuiteRun
     * const TestSuiteRun = await prisma.testSuiteRun.create({
     *   data: {
     *     // ... data to create a TestSuiteRun
     *   }
     * })
     * 
     */
    create<T extends TestSuiteRunCreateArgs>(args: SelectSubset<T, TestSuiteRunCreateArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TestSuiteRuns and returns the data saved in the database.
     * @param {TestSuiteRunCreateManyAndReturnArgs} args - Arguments to create many TestSuiteRuns.
     * @example
     * // Create many TestSuiteRuns
     * const testSuiteRun = await prisma.testSuiteRun.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TestSuiteRuns and only return the `id`
     * const testSuiteRunWithIdOnly = await prisma.testSuiteRun.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 TestSuiteRunCreateManyAndReturnArgs>(args?: SelectSubset<T, TestSuiteRunCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TestSuiteRun.
     * @param {TestSuiteRunDeleteArgs} args - Arguments to delete one TestSuiteRun.
     * @example
     * // Delete one TestSuiteRun
     * const TestSuiteRun = await prisma.testSuiteRun.delete({
     *   where: {
     *     // ... filter to delete one TestSuiteRun
     *   }
     * })
     * 
     */
    delete<T extends TestSuiteRunDeleteArgs>(args: SelectSubset<T, TestSuiteRunDeleteArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the TestSuiteRun model
   */
  interface TestSuiteRunFieldRefs {
    readonly id: FieldRef<"TestSuiteRun", 'String'>
    readonly workflowId: FieldRef<"TestSuiteRun", 'String'>
    readonly triggerNodeId: FieldRef<"TestSuiteRun", 'String'>
    readonly triggerNodeName: FieldRef<"TestSuiteRun", 'String'>
    readonly status: FieldRef<"TestSuiteRun", 'String'>
    readonly concurrency: FieldRef<"TestSuiteRun", 'Int'>
    readonly startedAt: FieldRef<"TestSuiteRun", 'String'>
    readonly finishedAt: FieldRef<"TestSuiteRun", 'String'>
    readonly totalCases: FieldRef<"TestSuiteRun", 'Int'>
    readonly passedCases: FieldRef<"TestSuiteRun", 'Int'>
    readonly failedCases: FieldRef<"TestSuiteRun", 'Int'>
    readonly nodeCoverageJson: FieldRef<"TestSuiteRun", 'String'>
    readonly errorMessage: FieldRef<"TestSuiteRun", 'String'>
    readonly updatedAt: FieldRef<"TestSuiteRun", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TestSuiteRun findUnique
   */
  export type TestSuiteRunFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * Filter, which TestSuiteRun to fetch.
     */
    where: TestSuiteRunWhereUniqueInput
  }

  /**
   * TestSuiteRun findUniqueOrThrow
   */
  export type TestSuiteRunFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * Filter, which TestSuiteRun to fetch.
     */
    where: TestSuiteRunWhereUniqueInput
  }

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

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

  /**
   * TestSuiteRun findMany
   */
  export type TestSuiteRunFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * Filter, which TestSuiteRuns to fetch.
     */
    where?: TestSuiteRunWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TestSuiteRuns to fetch.
     */
    orderBy?: TestSuiteRunOrderByWithRelationInput | TestSuiteRunOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TestSuiteRuns.
     */
    cursor?: TestSuiteRunWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TestSuiteRuns 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` TestSuiteRuns.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TestSuiteRuns.
     */
    distinct?: TestSuiteRunScalarFieldEnum | TestSuiteRunScalarFieldEnum[]
  }

  /**
   * TestSuiteRun create
   */
  export type TestSuiteRunCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * The data needed to create a TestSuiteRun.
     */
    data: XOR<TestSuiteRunCreateInput, TestSuiteRunUncheckedCreateInput>
  }

  /**
   * TestSuiteRun createMany
   */
  export type TestSuiteRunCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TestSuiteRuns.
     */
    data: TestSuiteRunCreateManyInput | TestSuiteRunCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TestSuiteRun createManyAndReturn
   */
  export type TestSuiteRunCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * The data used to create many TestSuiteRuns.
     */
    data: TestSuiteRunCreateManyInput | TestSuiteRunCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TestSuiteRun update
   */
  export type TestSuiteRunUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * The data needed to update a TestSuiteRun.
     */
    data: XOR<TestSuiteRunUpdateInput, TestSuiteRunUncheckedUpdateInput>
    /**
     * Choose, which TestSuiteRun to update.
     */
    where: TestSuiteRunWhereUniqueInput
  }

  /**
   * TestSuiteRun updateMany
   */
  export type TestSuiteRunUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TestSuiteRuns.
     */
    data: XOR<TestSuiteRunUpdateManyMutationInput, TestSuiteRunUncheckedUpdateManyInput>
    /**
     * Filter which TestSuiteRuns to update
     */
    where?: TestSuiteRunWhereInput
    /**
     * Limit how many TestSuiteRuns to update.
     */
    limit?: number
  }

  /**
   * TestSuiteRun updateManyAndReturn
   */
  export type TestSuiteRunUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * The data used to update TestSuiteRuns.
     */
    data: XOR<TestSuiteRunUpdateManyMutationInput, TestSuiteRunUncheckedUpdateManyInput>
    /**
     * Filter which TestSuiteRuns to update
     */
    where?: TestSuiteRunWhereInput
    /**
     * Limit how many TestSuiteRuns to update.
     */
    limit?: number
  }

  /**
   * TestSuiteRun upsert
   */
  export type TestSuiteRunUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * The filter to search for the TestSuiteRun to update in case it exists.
     */
    where: TestSuiteRunWhereUniqueInput
    /**
     * In case the TestSuiteRun found by the `where` argument doesn't exist, create a new TestSuiteRun with this data.
     */
    create: XOR<TestSuiteRunCreateInput, TestSuiteRunUncheckedCreateInput>
    /**
     * In case the TestSuiteRun was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TestSuiteRunUpdateInput, TestSuiteRunUncheckedUpdateInput>
  }

  /**
   * TestSuiteRun delete
   */
  export type TestSuiteRunDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestSuiteRun
     */
    select?: TestSuiteRunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestSuiteRun
     */
    omit?: TestSuiteRunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestSuiteRunInclude<ExtArgs> | null
    /**
     * Filter which TestSuiteRun to delete.
     */
    where: TestSuiteRunWhereUniqueInput
  }

  /**
   * TestSuiteRun deleteMany
   */
  export type TestSuiteRunDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TestSuiteRuns to delete
     */
    where?: TestSuiteRunWhereInput
    /**
     * Limit how many TestSuiteRuns to delete.
     */
    limit?: number
  }

  /**
   * TestSuiteRun.runs
   */
  export type TestSuiteRun$runsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    where?: RunWhereInput
    orderBy?: RunOrderByWithRelationInput | RunOrderByWithRelationInput[]
    cursor?: RunWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RunScalarFieldEnum | RunScalarFieldEnum[]
  }

  /**
   * TestSuiteRun.assertions
   */
  export type TestSuiteRun$assertionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    where?: TestAssertionWhereInput
    orderBy?: TestAssertionOrderByWithRelationInput | TestAssertionOrderByWithRelationInput[]
    cursor?: TestAssertionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TestAssertionScalarFieldEnum | TestAssertionScalarFieldEnum[]
  }

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


  /**
   * Model TestAssertion
   */

  export type AggregateTestAssertion = {
    _count: TestAssertionCountAggregateOutputType | null
    _avg: TestAssertionAvgAggregateOutputType | null
    _sum: TestAssertionSumAggregateOutputType | null
    _min: TestAssertionMinAggregateOutputType | null
    _max: TestAssertionMaxAggregateOutputType | null
  }

  export type TestAssertionAvgAggregateOutputType = {
    itemIndex: number | null
    score: number | null
    passThreshold: number | null
  }

  export type TestAssertionSumAggregateOutputType = {
    itemIndex: number | null
    score: number | null
    passThreshold: number | null
  }

  export type TestAssertionMinAggregateOutputType = {
    id: string | null
    runId: string | null
    testSuiteRunId: string | null
    workflowId: string | null
    nodeId: string | null
    iterationId: string | null
    itemIndex: number | null
    name: string | null
    score: number | null
    passThreshold: number | null
    errored: boolean | null
    expectedJson: string | null
    actualJson: string | null
    message: string | null
    detailsJson: string | null
    createdAt: string | null
  }

  export type TestAssertionMaxAggregateOutputType = {
    id: string | null
    runId: string | null
    testSuiteRunId: string | null
    workflowId: string | null
    nodeId: string | null
    iterationId: string | null
    itemIndex: number | null
    name: string | null
    score: number | null
    passThreshold: number | null
    errored: boolean | null
    expectedJson: string | null
    actualJson: string | null
    message: string | null
    detailsJson: string | null
    createdAt: string | null
  }

  export type TestAssertionCountAggregateOutputType = {
    id: number
    runId: number
    testSuiteRunId: number
    workflowId: number
    nodeId: number
    iterationId: number
    itemIndex: number
    name: number
    score: number
    passThreshold: number
    errored: number
    expectedJson: number
    actualJson: number
    message: number
    detailsJson: number
    createdAt: number
    _all: number
  }


  export type TestAssertionAvgAggregateInputType = {
    itemIndex?: true
    score?: true
    passThreshold?: true
  }

  export type TestAssertionSumAggregateInputType = {
    itemIndex?: true
    score?: true
    passThreshold?: true
  }

  export type TestAssertionMinAggregateInputType = {
    id?: true
    runId?: true
    testSuiteRunId?: true
    workflowId?: true
    nodeId?: true
    iterationId?: true
    itemIndex?: true
    name?: true
    score?: true
    passThreshold?: true
    errored?: true
    expectedJson?: true
    actualJson?: true
    message?: true
    detailsJson?: true
    createdAt?: true
  }

  export type TestAssertionMaxAggregateInputType = {
    id?: true
    runId?: true
    testSuiteRunId?: true
    workflowId?: true
    nodeId?: true
    iterationId?: true
    itemIndex?: true
    name?: true
    score?: true
    passThreshold?: true
    errored?: true
    expectedJson?: true
    actualJson?: true
    message?: true
    detailsJson?: true
    createdAt?: true
  }

  export type TestAssertionCountAggregateInputType = {
    id?: true
    runId?: true
    testSuiteRunId?: true
    workflowId?: true
    nodeId?: true
    iterationId?: true
    itemIndex?: true
    name?: true
    score?: true
    passThreshold?: true
    errored?: true
    expectedJson?: true
    actualJson?: true
    message?: true
    detailsJson?: true
    createdAt?: true
    _all?: true
  }

  export type TestAssertionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TestAssertion to aggregate.
     */
    where?: TestAssertionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TestAssertions to fetch.
     */
    orderBy?: TestAssertionOrderByWithRelationInput | TestAssertionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TestAssertionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TestAssertions 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` TestAssertions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TestAssertions
    **/
    _count?: true | TestAssertionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TestAssertionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TestAssertionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TestAssertionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TestAssertionMaxAggregateInputType
  }

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




  export type TestAssertionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TestAssertionWhereInput
    orderBy?: TestAssertionOrderByWithAggregationInput | TestAssertionOrderByWithAggregationInput[]
    by: TestAssertionScalarFieldEnum[] | TestAssertionScalarFieldEnum
    having?: TestAssertionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TestAssertionCountAggregateInputType | true
    _avg?: TestAssertionAvgAggregateInputType
    _sum?: TestAssertionSumAggregateInputType
    _min?: TestAssertionMinAggregateInputType
    _max?: TestAssertionMaxAggregateInputType
  }

  export type TestAssertionGroupByOutputType = {
    id: string
    runId: string
    testSuiteRunId: string
    workflowId: string
    nodeId: string
    iterationId: string | null
    itemIndex: number | null
    name: string
    score: number
    passThreshold: number | null
    errored: boolean
    expectedJson: string | null
    actualJson: string | null
    message: string | null
    detailsJson: string | null
    createdAt: string
    _count: TestAssertionCountAggregateOutputType | null
    _avg: TestAssertionAvgAggregateOutputType | null
    _sum: TestAssertionSumAggregateOutputType | null
    _min: TestAssertionMinAggregateOutputType | null
    _max: TestAssertionMaxAggregateOutputType | null
  }

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


  export type TestAssertionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    runId?: boolean
    testSuiteRunId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    name?: boolean
    score?: boolean
    passThreshold?: boolean
    errored?: boolean
    expectedJson?: boolean
    actualJson?: boolean
    message?: boolean
    detailsJson?: boolean
    createdAt?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
    testSuiteRun?: boolean | TestSuiteRunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["testAssertion"]>

  export type TestAssertionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    runId?: boolean
    testSuiteRunId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    name?: boolean
    score?: boolean
    passThreshold?: boolean
    errored?: boolean
    expectedJson?: boolean
    actualJson?: boolean
    message?: boolean
    detailsJson?: boolean
    createdAt?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
    testSuiteRun?: boolean | TestSuiteRunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["testAssertion"]>

  export type TestAssertionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    runId?: boolean
    testSuiteRunId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    name?: boolean
    score?: boolean
    passThreshold?: boolean
    errored?: boolean
    expectedJson?: boolean
    actualJson?: boolean
    message?: boolean
    detailsJson?: boolean
    createdAt?: boolean
    run?: boolean | RunDefaultArgs<ExtArgs>
    testSuiteRun?: boolean | TestSuiteRunDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["testAssertion"]>

  export type TestAssertionSelectScalar = {
    id?: boolean
    runId?: boolean
    testSuiteRunId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    name?: boolean
    score?: boolean
    passThreshold?: boolean
    errored?: boolean
    expectedJson?: boolean
    actualJson?: boolean
    message?: boolean
    detailsJson?: boolean
    createdAt?: boolean
  }

  export type TestAssertionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "runId" | "testSuiteRunId" | "workflowId" | "nodeId" | "iterationId" | "itemIndex" | "name" | "score" | "passThreshold" | "errored" | "expectedJson" | "actualJson" | "message" | "detailsJson" | "createdAt", ExtArgs["result"]["testAssertion"]>
  export type TestAssertionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
    testSuiteRun?: boolean | TestSuiteRunDefaultArgs<ExtArgs>
  }
  export type TestAssertionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
    testSuiteRun?: boolean | TestSuiteRunDefaultArgs<ExtArgs>
  }
  export type TestAssertionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    run?: boolean | RunDefaultArgs<ExtArgs>
    testSuiteRun?: boolean | TestSuiteRunDefaultArgs<ExtArgs>
  }

  export type $TestAssertionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TestAssertion"
    objects: {
      run: Prisma.$RunPayload<ExtArgs>
      testSuiteRun: Prisma.$TestSuiteRunPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      runId: string
      testSuiteRunId: string
      workflowId: string
      nodeId: string
      iterationId: string | null
      itemIndex: number | null
      name: string
      score: number
      passThreshold: number | null
      errored: boolean
      expectedJson: string | null
      actualJson: string | null
      message: string | null
      detailsJson: string | null
      createdAt: string
    }, ExtArgs["result"]["testAssertion"]>
    composites: {}
  }

  type TestAssertionGetPayload<S extends boolean | null | undefined | TestAssertionDefaultArgs> = $Result.GetResult<Prisma.$TestAssertionPayload, S>

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

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

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

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

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

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

    /**
     * Create a TestAssertion.
     * @param {TestAssertionCreateArgs} args - Arguments to create a TestAssertion.
     * @example
     * // Create one TestAssertion
     * const TestAssertion = await prisma.testAssertion.create({
     *   data: {
     *     // ... data to create a TestAssertion
     *   }
     * })
     * 
     */
    create<T extends TestAssertionCreateArgs>(args: SelectSubset<T, TestAssertionCreateArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TestAssertions and returns the data saved in the database.
     * @param {TestAssertionCreateManyAndReturnArgs} args - Arguments to create many TestAssertions.
     * @example
     * // Create many TestAssertions
     * const testAssertion = await prisma.testAssertion.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TestAssertions and only return the `id`
     * const testAssertionWithIdOnly = await prisma.testAssertion.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 TestAssertionCreateManyAndReturnArgs>(args?: SelectSubset<T, TestAssertionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TestAssertion.
     * @param {TestAssertionDeleteArgs} args - Arguments to delete one TestAssertion.
     * @example
     * // Delete one TestAssertion
     * const TestAssertion = await prisma.testAssertion.delete({
     *   where: {
     *     // ... filter to delete one TestAssertion
     *   }
     * })
     * 
     */
    delete<T extends TestAssertionDeleteArgs>(args: SelectSubset<T, TestAssertionDeleteArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the TestAssertion model
   */
  interface TestAssertionFieldRefs {
    readonly id: FieldRef<"TestAssertion", 'String'>
    readonly runId: FieldRef<"TestAssertion", 'String'>
    readonly testSuiteRunId: FieldRef<"TestAssertion", 'String'>
    readonly workflowId: FieldRef<"TestAssertion", 'String'>
    readonly nodeId: FieldRef<"TestAssertion", 'String'>
    readonly iterationId: FieldRef<"TestAssertion", 'String'>
    readonly itemIndex: FieldRef<"TestAssertion", 'Int'>
    readonly name: FieldRef<"TestAssertion", 'String'>
    readonly score: FieldRef<"TestAssertion", 'Float'>
    readonly passThreshold: FieldRef<"TestAssertion", 'Float'>
    readonly errored: FieldRef<"TestAssertion", 'Boolean'>
    readonly expectedJson: FieldRef<"TestAssertion", 'String'>
    readonly actualJson: FieldRef<"TestAssertion", 'String'>
    readonly message: FieldRef<"TestAssertion", 'String'>
    readonly detailsJson: FieldRef<"TestAssertion", 'String'>
    readonly createdAt: FieldRef<"TestAssertion", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TestAssertion findUnique
   */
  export type TestAssertionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * Filter, which TestAssertion to fetch.
     */
    where: TestAssertionWhereUniqueInput
  }

  /**
   * TestAssertion findUniqueOrThrow
   */
  export type TestAssertionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * Filter, which TestAssertion to fetch.
     */
    where: TestAssertionWhereUniqueInput
  }

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

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

  /**
   * TestAssertion findMany
   */
  export type TestAssertionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * Filter, which TestAssertions to fetch.
     */
    where?: TestAssertionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TestAssertions to fetch.
     */
    orderBy?: TestAssertionOrderByWithRelationInput | TestAssertionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TestAssertions.
     */
    cursor?: TestAssertionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TestAssertions 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` TestAssertions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TestAssertions.
     */
    distinct?: TestAssertionScalarFieldEnum | TestAssertionScalarFieldEnum[]
  }

  /**
   * TestAssertion create
   */
  export type TestAssertionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * The data needed to create a TestAssertion.
     */
    data: XOR<TestAssertionCreateInput, TestAssertionUncheckedCreateInput>
  }

  /**
   * TestAssertion createMany
   */
  export type TestAssertionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TestAssertions.
     */
    data: TestAssertionCreateManyInput | TestAssertionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TestAssertion createManyAndReturn
   */
  export type TestAssertionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * The data used to create many TestAssertions.
     */
    data: TestAssertionCreateManyInput | TestAssertionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * TestAssertion update
   */
  export type TestAssertionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * The data needed to update a TestAssertion.
     */
    data: XOR<TestAssertionUpdateInput, TestAssertionUncheckedUpdateInput>
    /**
     * Choose, which TestAssertion to update.
     */
    where: TestAssertionWhereUniqueInput
  }

  /**
   * TestAssertion updateMany
   */
  export type TestAssertionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TestAssertions.
     */
    data: XOR<TestAssertionUpdateManyMutationInput, TestAssertionUncheckedUpdateManyInput>
    /**
     * Filter which TestAssertions to update
     */
    where?: TestAssertionWhereInput
    /**
     * Limit how many TestAssertions to update.
     */
    limit?: number
  }

  /**
   * TestAssertion updateManyAndReturn
   */
  export type TestAssertionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * The data used to update TestAssertions.
     */
    data: XOR<TestAssertionUpdateManyMutationInput, TestAssertionUncheckedUpdateManyInput>
    /**
     * Filter which TestAssertions to update
     */
    where?: TestAssertionWhereInput
    /**
     * Limit how many TestAssertions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * TestAssertion upsert
   */
  export type TestAssertionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * The filter to search for the TestAssertion to update in case it exists.
     */
    where: TestAssertionWhereUniqueInput
    /**
     * In case the TestAssertion found by the `where` argument doesn't exist, create a new TestAssertion with this data.
     */
    create: XOR<TestAssertionCreateInput, TestAssertionUncheckedCreateInput>
    /**
     * In case the TestAssertion was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TestAssertionUpdateInput, TestAssertionUncheckedUpdateInput>
  }

  /**
   * TestAssertion delete
   */
  export type TestAssertionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TestAssertion
     */
    select?: TestAssertionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TestAssertion
     */
    omit?: TestAssertionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TestAssertionInclude<ExtArgs> | null
    /**
     * Filter which TestAssertion to delete.
     */
    where: TestAssertionWhereUniqueInput
  }

  /**
   * TestAssertion deleteMany
   */
  export type TestAssertionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TestAssertions to delete
     */
    where?: TestAssertionWhereInput
    /**
     * Limit how many TestAssertions to delete.
     */
    limit?: number
  }

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


  /**
   * Model WorkflowDebuggerOverlay
   */

  export type AggregateWorkflowDebuggerOverlay = {
    _count: WorkflowDebuggerOverlayCountAggregateOutputType | null
    _min: WorkflowDebuggerOverlayMinAggregateOutputType | null
    _max: WorkflowDebuggerOverlayMaxAggregateOutputType | null
  }

  export type WorkflowDebuggerOverlayMinAggregateOutputType = {
    workflowId: string | null
    updatedAt: string | null
    copiedFromRunId: string | null
    stateJson: string | null
  }

  export type WorkflowDebuggerOverlayMaxAggregateOutputType = {
    workflowId: string | null
    updatedAt: string | null
    copiedFromRunId: string | null
    stateJson: string | null
  }

  export type WorkflowDebuggerOverlayCountAggregateOutputType = {
    workflowId: number
    updatedAt: number
    copiedFromRunId: number
    stateJson: number
    _all: number
  }


  export type WorkflowDebuggerOverlayMinAggregateInputType = {
    workflowId?: true
    updatedAt?: true
    copiedFromRunId?: true
    stateJson?: true
  }

  export type WorkflowDebuggerOverlayMaxAggregateInputType = {
    workflowId?: true
    updatedAt?: true
    copiedFromRunId?: true
    stateJson?: true
  }

  export type WorkflowDebuggerOverlayCountAggregateInputType = {
    workflowId?: true
    updatedAt?: true
    copiedFromRunId?: true
    stateJson?: true
    _all?: true
  }

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

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




  export type WorkflowDebuggerOverlayGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WorkflowDebuggerOverlayWhereInput
    orderBy?: WorkflowDebuggerOverlayOrderByWithAggregationInput | WorkflowDebuggerOverlayOrderByWithAggregationInput[]
    by: WorkflowDebuggerOverlayScalarFieldEnum[] | WorkflowDebuggerOverlayScalarFieldEnum
    having?: WorkflowDebuggerOverlayScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WorkflowDebuggerOverlayCountAggregateInputType | true
    _min?: WorkflowDebuggerOverlayMinAggregateInputType
    _max?: WorkflowDebuggerOverlayMaxAggregateInputType
  }

  export type WorkflowDebuggerOverlayGroupByOutputType = {
    workflowId: string
    updatedAt: string
    copiedFromRunId: string | null
    stateJson: string
    _count: WorkflowDebuggerOverlayCountAggregateOutputType | null
    _min: WorkflowDebuggerOverlayMinAggregateOutputType | null
    _max: WorkflowDebuggerOverlayMaxAggregateOutputType | null
  }

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


  export type WorkflowDebuggerOverlaySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    updatedAt?: boolean
    copiedFromRunId?: boolean
    stateJson?: boolean
  }, ExtArgs["result"]["workflowDebuggerOverlay"]>

  export type WorkflowDebuggerOverlaySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    updatedAt?: boolean
    copiedFromRunId?: boolean
    stateJson?: boolean
  }, ExtArgs["result"]["workflowDebuggerOverlay"]>

  export type WorkflowDebuggerOverlaySelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    updatedAt?: boolean
    copiedFromRunId?: boolean
    stateJson?: boolean
  }, ExtArgs["result"]["workflowDebuggerOverlay"]>

  export type WorkflowDebuggerOverlaySelectScalar = {
    workflowId?: boolean
    updatedAt?: boolean
    copiedFromRunId?: boolean
    stateJson?: boolean
  }

  export type WorkflowDebuggerOverlayOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"workflowId" | "updatedAt" | "copiedFromRunId" | "stateJson", ExtArgs["result"]["workflowDebuggerOverlay"]>

  export type $WorkflowDebuggerOverlayPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WorkflowDebuggerOverlay"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      workflowId: string
      updatedAt: string
      copiedFromRunId: string | null
      stateJson: string
    }, ExtArgs["result"]["workflowDebuggerOverlay"]>
    composites: {}
  }

  type WorkflowDebuggerOverlayGetPayload<S extends boolean | null | undefined | WorkflowDebuggerOverlayDefaultArgs> = $Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload, S>

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

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

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

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

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

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

    /**
     * Create a WorkflowDebuggerOverlay.
     * @param {WorkflowDebuggerOverlayCreateArgs} args - Arguments to create a WorkflowDebuggerOverlay.
     * @example
     * // Create one WorkflowDebuggerOverlay
     * const WorkflowDebuggerOverlay = await prisma.workflowDebuggerOverlay.create({
     *   data: {
     *     // ... data to create a WorkflowDebuggerOverlay
     *   }
     * })
     * 
     */
    create<T extends WorkflowDebuggerOverlayCreateArgs>(args: SelectSubset<T, WorkflowDebuggerOverlayCreateArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many WorkflowDebuggerOverlays and returns the data saved in the database.
     * @param {WorkflowDebuggerOverlayCreateManyAndReturnArgs} args - Arguments to create many WorkflowDebuggerOverlays.
     * @example
     * // Create many WorkflowDebuggerOverlays
     * const workflowDebuggerOverlay = await prisma.workflowDebuggerOverlay.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many WorkflowDebuggerOverlays and only return the `workflowId`
     * const workflowDebuggerOverlayWithWorkflowIdOnly = await prisma.workflowDebuggerOverlay.createManyAndReturn({
     *   select: { workflowId: 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 WorkflowDebuggerOverlayCreateManyAndReturnArgs>(args?: SelectSubset<T, WorkflowDebuggerOverlayCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a WorkflowDebuggerOverlay.
     * @param {WorkflowDebuggerOverlayDeleteArgs} args - Arguments to delete one WorkflowDebuggerOverlay.
     * @example
     * // Delete one WorkflowDebuggerOverlay
     * const WorkflowDebuggerOverlay = await prisma.workflowDebuggerOverlay.delete({
     *   where: {
     *     // ... filter to delete one WorkflowDebuggerOverlay
     *   }
     * })
     * 
     */
    delete<T extends WorkflowDebuggerOverlayDeleteArgs>(args: SelectSubset<T, WorkflowDebuggerOverlayDeleteArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the WorkflowDebuggerOverlay model
   */
  interface WorkflowDebuggerOverlayFieldRefs {
    readonly workflowId: FieldRef<"WorkflowDebuggerOverlay", 'String'>
    readonly updatedAt: FieldRef<"WorkflowDebuggerOverlay", 'String'>
    readonly copiedFromRunId: FieldRef<"WorkflowDebuggerOverlay", 'String'>
    readonly stateJson: FieldRef<"WorkflowDebuggerOverlay", 'String'>
  }
    

  // Custom InputTypes
  /**
   * WorkflowDebuggerOverlay findUnique
   */
  export type WorkflowDebuggerOverlayFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowDebuggerOverlay to fetch.
     */
    where: WorkflowDebuggerOverlayWhereUniqueInput
  }

  /**
   * WorkflowDebuggerOverlay findUniqueOrThrow
   */
  export type WorkflowDebuggerOverlayFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowDebuggerOverlay to fetch.
     */
    where: WorkflowDebuggerOverlayWhereUniqueInput
  }

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

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

  /**
   * WorkflowDebuggerOverlay findMany
   */
  export type WorkflowDebuggerOverlayFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowDebuggerOverlays to fetch.
     */
    where?: WorkflowDebuggerOverlayWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WorkflowDebuggerOverlays to fetch.
     */
    orderBy?: WorkflowDebuggerOverlayOrderByWithRelationInput | WorkflowDebuggerOverlayOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WorkflowDebuggerOverlays.
     */
    cursor?: WorkflowDebuggerOverlayWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WorkflowDebuggerOverlays 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` WorkflowDebuggerOverlays.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of WorkflowDebuggerOverlays.
     */
    distinct?: WorkflowDebuggerOverlayScalarFieldEnum | WorkflowDebuggerOverlayScalarFieldEnum[]
  }

  /**
   * WorkflowDebuggerOverlay create
   */
  export type WorkflowDebuggerOverlayCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * The data needed to create a WorkflowDebuggerOverlay.
     */
    data: XOR<WorkflowDebuggerOverlayCreateInput, WorkflowDebuggerOverlayUncheckedCreateInput>
  }

  /**
   * WorkflowDebuggerOverlay createMany
   */
  export type WorkflowDebuggerOverlayCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many WorkflowDebuggerOverlays.
     */
    data: WorkflowDebuggerOverlayCreateManyInput | WorkflowDebuggerOverlayCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowDebuggerOverlay createManyAndReturn
   */
  export type WorkflowDebuggerOverlayCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * The data used to create many WorkflowDebuggerOverlays.
     */
    data: WorkflowDebuggerOverlayCreateManyInput | WorkflowDebuggerOverlayCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowDebuggerOverlay update
   */
  export type WorkflowDebuggerOverlayUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * The data needed to update a WorkflowDebuggerOverlay.
     */
    data: XOR<WorkflowDebuggerOverlayUpdateInput, WorkflowDebuggerOverlayUncheckedUpdateInput>
    /**
     * Choose, which WorkflowDebuggerOverlay to update.
     */
    where: WorkflowDebuggerOverlayWhereUniqueInput
  }

  /**
   * WorkflowDebuggerOverlay updateMany
   */
  export type WorkflowDebuggerOverlayUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WorkflowDebuggerOverlays.
     */
    data: XOR<WorkflowDebuggerOverlayUpdateManyMutationInput, WorkflowDebuggerOverlayUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowDebuggerOverlays to update
     */
    where?: WorkflowDebuggerOverlayWhereInput
    /**
     * Limit how many WorkflowDebuggerOverlays to update.
     */
    limit?: number
  }

  /**
   * WorkflowDebuggerOverlay updateManyAndReturn
   */
  export type WorkflowDebuggerOverlayUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * The data used to update WorkflowDebuggerOverlays.
     */
    data: XOR<WorkflowDebuggerOverlayUpdateManyMutationInput, WorkflowDebuggerOverlayUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowDebuggerOverlays to update
     */
    where?: WorkflowDebuggerOverlayWhereInput
    /**
     * Limit how many WorkflowDebuggerOverlays to update.
     */
    limit?: number
  }

  /**
   * WorkflowDebuggerOverlay upsert
   */
  export type WorkflowDebuggerOverlayUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * The filter to search for the WorkflowDebuggerOverlay to update in case it exists.
     */
    where: WorkflowDebuggerOverlayWhereUniqueInput
    /**
     * In case the WorkflowDebuggerOverlay found by the `where` argument doesn't exist, create a new WorkflowDebuggerOverlay with this data.
     */
    create: XOR<WorkflowDebuggerOverlayCreateInput, WorkflowDebuggerOverlayUncheckedCreateInput>
    /**
     * In case the WorkflowDebuggerOverlay was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WorkflowDebuggerOverlayUpdateInput, WorkflowDebuggerOverlayUncheckedUpdateInput>
  }

  /**
   * WorkflowDebuggerOverlay delete
   */
  export type WorkflowDebuggerOverlayDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowDebuggerOverlay
     */
    select?: WorkflowDebuggerOverlaySelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowDebuggerOverlay
     */
    omit?: WorkflowDebuggerOverlayOmit<ExtArgs> | null
    /**
     * Filter which WorkflowDebuggerOverlay to delete.
     */
    where: WorkflowDebuggerOverlayWhereUniqueInput
  }

  /**
   * WorkflowDebuggerOverlay deleteMany
   */
  export type WorkflowDebuggerOverlayDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WorkflowDebuggerOverlays to delete
     */
    where?: WorkflowDebuggerOverlayWhereInput
    /**
     * Limit how many WorkflowDebuggerOverlays to delete.
     */
    limit?: number
  }

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


  /**
   * Model WorkflowActivation
   */

  export type AggregateWorkflowActivation = {
    _count: WorkflowActivationCountAggregateOutputType | null
    _min: WorkflowActivationMinAggregateOutputType | null
    _max: WorkflowActivationMaxAggregateOutputType | null
  }

  export type WorkflowActivationMinAggregateOutputType = {
    workflowId: string | null
    isActive: boolean | null
    updatedAt: string | null
  }

  export type WorkflowActivationMaxAggregateOutputType = {
    workflowId: string | null
    isActive: boolean | null
    updatedAt: string | null
  }

  export type WorkflowActivationCountAggregateOutputType = {
    workflowId: number
    isActive: number
    updatedAt: number
    _all: number
  }


  export type WorkflowActivationMinAggregateInputType = {
    workflowId?: true
    isActive?: true
    updatedAt?: true
  }

  export type WorkflowActivationMaxAggregateInputType = {
    workflowId?: true
    isActive?: true
    updatedAt?: true
  }

  export type WorkflowActivationCountAggregateInputType = {
    workflowId?: true
    isActive?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type WorkflowActivationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WorkflowActivationWhereInput
    orderBy?: WorkflowActivationOrderByWithAggregationInput | WorkflowActivationOrderByWithAggregationInput[]
    by: WorkflowActivationScalarFieldEnum[] | WorkflowActivationScalarFieldEnum
    having?: WorkflowActivationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WorkflowActivationCountAggregateInputType | true
    _min?: WorkflowActivationMinAggregateInputType
    _max?: WorkflowActivationMaxAggregateInputType
  }

  export type WorkflowActivationGroupByOutputType = {
    workflowId: string
    isActive: boolean
    updatedAt: string
    _count: WorkflowActivationCountAggregateOutputType | null
    _min: WorkflowActivationMinAggregateOutputType | null
    _max: WorkflowActivationMaxAggregateOutputType | null
  }

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


  export type WorkflowActivationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    isActive?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["workflowActivation"]>

  export type WorkflowActivationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    isActive?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["workflowActivation"]>

  export type WorkflowActivationSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    isActive?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["workflowActivation"]>

  export type WorkflowActivationSelectScalar = {
    workflowId?: boolean
    isActive?: boolean
    updatedAt?: boolean
  }

  export type WorkflowActivationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"workflowId" | "isActive" | "updatedAt", ExtArgs["result"]["workflowActivation"]>

  export type $WorkflowActivationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WorkflowActivation"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      workflowId: string
      isActive: boolean
      updatedAt: string
    }, ExtArgs["result"]["workflowActivation"]>
    composites: {}
  }

  type WorkflowActivationGetPayload<S extends boolean | null | undefined | WorkflowActivationDefaultArgs> = $Result.GetResult<Prisma.$WorkflowActivationPayload, S>

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

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

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

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

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

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

    /**
     * Create a WorkflowActivation.
     * @param {WorkflowActivationCreateArgs} args - Arguments to create a WorkflowActivation.
     * @example
     * // Create one WorkflowActivation
     * const WorkflowActivation = await prisma.workflowActivation.create({
     *   data: {
     *     // ... data to create a WorkflowActivation
     *   }
     * })
     * 
     */
    create<T extends WorkflowActivationCreateArgs>(args: SelectSubset<T, WorkflowActivationCreateArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many WorkflowActivations and returns the data saved in the database.
     * @param {WorkflowActivationCreateManyAndReturnArgs} args - Arguments to create many WorkflowActivations.
     * @example
     * // Create many WorkflowActivations
     * const workflowActivation = await prisma.workflowActivation.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many WorkflowActivations and only return the `workflowId`
     * const workflowActivationWithWorkflowIdOnly = await prisma.workflowActivation.createManyAndReturn({
     *   select: { workflowId: 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 WorkflowActivationCreateManyAndReturnArgs>(args?: SelectSubset<T, WorkflowActivationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a WorkflowActivation.
     * @param {WorkflowActivationDeleteArgs} args - Arguments to delete one WorkflowActivation.
     * @example
     * // Delete one WorkflowActivation
     * const WorkflowActivation = await prisma.workflowActivation.delete({
     *   where: {
     *     // ... filter to delete one WorkflowActivation
     *   }
     * })
     * 
     */
    delete<T extends WorkflowActivationDeleteArgs>(args: SelectSubset<T, WorkflowActivationDeleteArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the WorkflowActivation model
   */
  interface WorkflowActivationFieldRefs {
    readonly workflowId: FieldRef<"WorkflowActivation", 'String'>
    readonly isActive: FieldRef<"WorkflowActivation", 'Boolean'>
    readonly updatedAt: FieldRef<"WorkflowActivation", 'String'>
  }
    

  // Custom InputTypes
  /**
   * WorkflowActivation findUnique
   */
  export type WorkflowActivationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowActivation to fetch.
     */
    where: WorkflowActivationWhereUniqueInput
  }

  /**
   * WorkflowActivation findUniqueOrThrow
   */
  export type WorkflowActivationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowActivation to fetch.
     */
    where: WorkflowActivationWhereUniqueInput
  }

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

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

  /**
   * WorkflowActivation findMany
   */
  export type WorkflowActivationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowActivations to fetch.
     */
    where?: WorkflowActivationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WorkflowActivations to fetch.
     */
    orderBy?: WorkflowActivationOrderByWithRelationInput | WorkflowActivationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WorkflowActivations.
     */
    cursor?: WorkflowActivationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WorkflowActivations 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` WorkflowActivations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of WorkflowActivations.
     */
    distinct?: WorkflowActivationScalarFieldEnum | WorkflowActivationScalarFieldEnum[]
  }

  /**
   * WorkflowActivation create
   */
  export type WorkflowActivationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * The data needed to create a WorkflowActivation.
     */
    data: XOR<WorkflowActivationCreateInput, WorkflowActivationUncheckedCreateInput>
  }

  /**
   * WorkflowActivation createMany
   */
  export type WorkflowActivationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many WorkflowActivations.
     */
    data: WorkflowActivationCreateManyInput | WorkflowActivationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowActivation createManyAndReturn
   */
  export type WorkflowActivationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * The data used to create many WorkflowActivations.
     */
    data: WorkflowActivationCreateManyInput | WorkflowActivationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowActivation update
   */
  export type WorkflowActivationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * The data needed to update a WorkflowActivation.
     */
    data: XOR<WorkflowActivationUpdateInput, WorkflowActivationUncheckedUpdateInput>
    /**
     * Choose, which WorkflowActivation to update.
     */
    where: WorkflowActivationWhereUniqueInput
  }

  /**
   * WorkflowActivation updateMany
   */
  export type WorkflowActivationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WorkflowActivations.
     */
    data: XOR<WorkflowActivationUpdateManyMutationInput, WorkflowActivationUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowActivations to update
     */
    where?: WorkflowActivationWhereInput
    /**
     * Limit how many WorkflowActivations to update.
     */
    limit?: number
  }

  /**
   * WorkflowActivation updateManyAndReturn
   */
  export type WorkflowActivationUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * The data used to update WorkflowActivations.
     */
    data: XOR<WorkflowActivationUpdateManyMutationInput, WorkflowActivationUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowActivations to update
     */
    where?: WorkflowActivationWhereInput
    /**
     * Limit how many WorkflowActivations to update.
     */
    limit?: number
  }

  /**
   * WorkflowActivation upsert
   */
  export type WorkflowActivationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * The filter to search for the WorkflowActivation to update in case it exists.
     */
    where: WorkflowActivationWhereUniqueInput
    /**
     * In case the WorkflowActivation found by the `where` argument doesn't exist, create a new WorkflowActivation with this data.
     */
    create: XOR<WorkflowActivationCreateInput, WorkflowActivationUncheckedCreateInput>
    /**
     * In case the WorkflowActivation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WorkflowActivationUpdateInput, WorkflowActivationUncheckedUpdateInput>
  }

  /**
   * WorkflowActivation delete
   */
  export type WorkflowActivationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowActivation
     */
    select?: WorkflowActivationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowActivation
     */
    omit?: WorkflowActivationOmit<ExtArgs> | null
    /**
     * Filter which WorkflowActivation to delete.
     */
    where: WorkflowActivationWhereUniqueInput
  }

  /**
   * WorkflowActivation deleteMany
   */
  export type WorkflowActivationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WorkflowActivations to delete
     */
    where?: WorkflowActivationWhereInput
    /**
     * Limit how many WorkflowActivations to delete.
     */
    limit?: number
  }

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


  /**
   * Model TriggerSetupState
   */

  export type AggregateTriggerSetupState = {
    _count: TriggerSetupStateCountAggregateOutputType | null
    _min: TriggerSetupStateMinAggregateOutputType | null
    _max: TriggerSetupStateMaxAggregateOutputType | null
  }

  export type TriggerSetupStateMinAggregateOutputType = {
    workflowId: string | null
    nodeId: string | null
    updatedAt: string | null
    stateJson: string | null
  }

  export type TriggerSetupStateMaxAggregateOutputType = {
    workflowId: string | null
    nodeId: string | null
    updatedAt: string | null
    stateJson: string | null
  }

  export type TriggerSetupStateCountAggregateOutputType = {
    workflowId: number
    nodeId: number
    updatedAt: number
    stateJson: number
    _all: number
  }


  export type TriggerSetupStateMinAggregateInputType = {
    workflowId?: true
    nodeId?: true
    updatedAt?: true
    stateJson?: true
  }

  export type TriggerSetupStateMaxAggregateInputType = {
    workflowId?: true
    nodeId?: true
    updatedAt?: true
    stateJson?: true
  }

  export type TriggerSetupStateCountAggregateInputType = {
    workflowId?: true
    nodeId?: true
    updatedAt?: true
    stateJson?: true
    _all?: true
  }

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

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




  export type TriggerSetupStateGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TriggerSetupStateWhereInput
    orderBy?: TriggerSetupStateOrderByWithAggregationInput | TriggerSetupStateOrderByWithAggregationInput[]
    by: TriggerSetupStateScalarFieldEnum[] | TriggerSetupStateScalarFieldEnum
    having?: TriggerSetupStateScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TriggerSetupStateCountAggregateInputType | true
    _min?: TriggerSetupStateMinAggregateInputType
    _max?: TriggerSetupStateMaxAggregateInputType
  }

  export type TriggerSetupStateGroupByOutputType = {
    workflowId: string
    nodeId: string
    updatedAt: string
    stateJson: string
    _count: TriggerSetupStateCountAggregateOutputType | null
    _min: TriggerSetupStateMinAggregateOutputType | null
    _max: TriggerSetupStateMaxAggregateOutputType | null
  }

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


  export type TriggerSetupStateSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    nodeId?: boolean
    updatedAt?: boolean
    stateJson?: boolean
  }, ExtArgs["result"]["triggerSetupState"]>

  export type TriggerSetupStateSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    nodeId?: boolean
    updatedAt?: boolean
    stateJson?: boolean
  }, ExtArgs["result"]["triggerSetupState"]>

  export type TriggerSetupStateSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    nodeId?: boolean
    updatedAt?: boolean
    stateJson?: boolean
  }, ExtArgs["result"]["triggerSetupState"]>

  export type TriggerSetupStateSelectScalar = {
    workflowId?: boolean
    nodeId?: boolean
    updatedAt?: boolean
    stateJson?: boolean
  }

  export type TriggerSetupStateOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"workflowId" | "nodeId" | "updatedAt" | "stateJson", ExtArgs["result"]["triggerSetupState"]>

  export type $TriggerSetupStatePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TriggerSetupState"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      workflowId: string
      nodeId: string
      updatedAt: string
      stateJson: string
    }, ExtArgs["result"]["triggerSetupState"]>
    composites: {}
  }

  type TriggerSetupStateGetPayload<S extends boolean | null | undefined | TriggerSetupStateDefaultArgs> = $Result.GetResult<Prisma.$TriggerSetupStatePayload, S>

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

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

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

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

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

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

    /**
     * Create a TriggerSetupState.
     * @param {TriggerSetupStateCreateArgs} args - Arguments to create a TriggerSetupState.
     * @example
     * // Create one TriggerSetupState
     * const TriggerSetupState = await prisma.triggerSetupState.create({
     *   data: {
     *     // ... data to create a TriggerSetupState
     *   }
     * })
     * 
     */
    create<T extends TriggerSetupStateCreateArgs>(args: SelectSubset<T, TriggerSetupStateCreateArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TriggerSetupStates and returns the data saved in the database.
     * @param {TriggerSetupStateCreateManyAndReturnArgs} args - Arguments to create many TriggerSetupStates.
     * @example
     * // Create many TriggerSetupStates
     * const triggerSetupState = await prisma.triggerSetupState.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TriggerSetupStates and only return the `workflowId`
     * const triggerSetupStateWithWorkflowIdOnly = await prisma.triggerSetupState.createManyAndReturn({
     *   select: { workflowId: 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 TriggerSetupStateCreateManyAndReturnArgs>(args?: SelectSubset<T, TriggerSetupStateCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TriggerSetupState.
     * @param {TriggerSetupStateDeleteArgs} args - Arguments to delete one TriggerSetupState.
     * @example
     * // Delete one TriggerSetupState
     * const TriggerSetupState = await prisma.triggerSetupState.delete({
     *   where: {
     *     // ... filter to delete one TriggerSetupState
     *   }
     * })
     * 
     */
    delete<T extends TriggerSetupStateDeleteArgs>(args: SelectSubset<T, TriggerSetupStateDeleteArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the TriggerSetupState model
   */
  interface TriggerSetupStateFieldRefs {
    readonly workflowId: FieldRef<"TriggerSetupState", 'String'>
    readonly nodeId: FieldRef<"TriggerSetupState", 'String'>
    readonly updatedAt: FieldRef<"TriggerSetupState", 'String'>
    readonly stateJson: FieldRef<"TriggerSetupState", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TriggerSetupState findUnique
   */
  export type TriggerSetupStateFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * Filter, which TriggerSetupState to fetch.
     */
    where: TriggerSetupStateWhereUniqueInput
  }

  /**
   * TriggerSetupState findUniqueOrThrow
   */
  export type TriggerSetupStateFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * Filter, which TriggerSetupState to fetch.
     */
    where: TriggerSetupStateWhereUniqueInput
  }

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

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

  /**
   * TriggerSetupState findMany
   */
  export type TriggerSetupStateFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * Filter, which TriggerSetupStates to fetch.
     */
    where?: TriggerSetupStateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TriggerSetupStates to fetch.
     */
    orderBy?: TriggerSetupStateOrderByWithRelationInput | TriggerSetupStateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TriggerSetupStates.
     */
    cursor?: TriggerSetupStateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TriggerSetupStates 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` TriggerSetupStates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TriggerSetupStates.
     */
    distinct?: TriggerSetupStateScalarFieldEnum | TriggerSetupStateScalarFieldEnum[]
  }

  /**
   * TriggerSetupState create
   */
  export type TriggerSetupStateCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * The data needed to create a TriggerSetupState.
     */
    data: XOR<TriggerSetupStateCreateInput, TriggerSetupStateUncheckedCreateInput>
  }

  /**
   * TriggerSetupState createMany
   */
  export type TriggerSetupStateCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TriggerSetupStates.
     */
    data: TriggerSetupStateCreateManyInput | TriggerSetupStateCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TriggerSetupState createManyAndReturn
   */
  export type TriggerSetupStateCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * The data used to create many TriggerSetupStates.
     */
    data: TriggerSetupStateCreateManyInput | TriggerSetupStateCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TriggerSetupState update
   */
  export type TriggerSetupStateUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * The data needed to update a TriggerSetupState.
     */
    data: XOR<TriggerSetupStateUpdateInput, TriggerSetupStateUncheckedUpdateInput>
    /**
     * Choose, which TriggerSetupState to update.
     */
    where: TriggerSetupStateWhereUniqueInput
  }

  /**
   * TriggerSetupState updateMany
   */
  export type TriggerSetupStateUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TriggerSetupStates.
     */
    data: XOR<TriggerSetupStateUpdateManyMutationInput, TriggerSetupStateUncheckedUpdateManyInput>
    /**
     * Filter which TriggerSetupStates to update
     */
    where?: TriggerSetupStateWhereInput
    /**
     * Limit how many TriggerSetupStates to update.
     */
    limit?: number
  }

  /**
   * TriggerSetupState updateManyAndReturn
   */
  export type TriggerSetupStateUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * The data used to update TriggerSetupStates.
     */
    data: XOR<TriggerSetupStateUpdateManyMutationInput, TriggerSetupStateUncheckedUpdateManyInput>
    /**
     * Filter which TriggerSetupStates to update
     */
    where?: TriggerSetupStateWhereInput
    /**
     * Limit how many TriggerSetupStates to update.
     */
    limit?: number
  }

  /**
   * TriggerSetupState upsert
   */
  export type TriggerSetupStateUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * The filter to search for the TriggerSetupState to update in case it exists.
     */
    where: TriggerSetupStateWhereUniqueInput
    /**
     * In case the TriggerSetupState found by the `where` argument doesn't exist, create a new TriggerSetupState with this data.
     */
    create: XOR<TriggerSetupStateCreateInput, TriggerSetupStateUncheckedCreateInput>
    /**
     * In case the TriggerSetupState was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TriggerSetupStateUpdateInput, TriggerSetupStateUncheckedUpdateInput>
  }

  /**
   * TriggerSetupState delete
   */
  export type TriggerSetupStateDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TriggerSetupState
     */
    select?: TriggerSetupStateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TriggerSetupState
     */
    omit?: TriggerSetupStateOmit<ExtArgs> | null
    /**
     * Filter which TriggerSetupState to delete.
     */
    where: TriggerSetupStateWhereUniqueInput
  }

  /**
   * TriggerSetupState deleteMany
   */
  export type TriggerSetupStateDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TriggerSetupStates to delete
     */
    where?: TriggerSetupStateWhereInput
    /**
     * Limit how many TriggerSetupStates to delete.
     */
    limit?: number
  }

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


  /**
   * Model RunTraceContext
   */

  export type AggregateRunTraceContext = {
    _count: RunTraceContextCountAggregateOutputType | null
    _min: RunTraceContextMinAggregateOutputType | null
    _max: RunTraceContextMaxAggregateOutputType | null
  }

  export type RunTraceContextMinAggregateOutputType = {
    runId: string | null
    workflowId: string | null
    traceId: string | null
    rootSpanId: string | null
    serviceName: string | null
    createdAt: string | null
    expiresAt: string | null
  }

  export type RunTraceContextMaxAggregateOutputType = {
    runId: string | null
    workflowId: string | null
    traceId: string | null
    rootSpanId: string | null
    serviceName: string | null
    createdAt: string | null
    expiresAt: string | null
  }

  export type RunTraceContextCountAggregateOutputType = {
    runId: number
    workflowId: number
    traceId: number
    rootSpanId: number
    serviceName: number
    createdAt: number
    expiresAt: number
    _all: number
  }


  export type RunTraceContextMinAggregateInputType = {
    runId?: true
    workflowId?: true
    traceId?: true
    rootSpanId?: true
    serviceName?: true
    createdAt?: true
    expiresAt?: true
  }

  export type RunTraceContextMaxAggregateInputType = {
    runId?: true
    workflowId?: true
    traceId?: true
    rootSpanId?: true
    serviceName?: true
    createdAt?: true
    expiresAt?: true
  }

  export type RunTraceContextCountAggregateInputType = {
    runId?: true
    workflowId?: true
    traceId?: true
    rootSpanId?: true
    serviceName?: true
    createdAt?: true
    expiresAt?: true
    _all?: true
  }

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

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




  export type RunTraceContextGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RunTraceContextWhereInput
    orderBy?: RunTraceContextOrderByWithAggregationInput | RunTraceContextOrderByWithAggregationInput[]
    by: RunTraceContextScalarFieldEnum[] | RunTraceContextScalarFieldEnum
    having?: RunTraceContextScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RunTraceContextCountAggregateInputType | true
    _min?: RunTraceContextMinAggregateInputType
    _max?: RunTraceContextMaxAggregateInputType
  }

  export type RunTraceContextGroupByOutputType = {
    runId: string
    workflowId: string
    traceId: string
    rootSpanId: string
    serviceName: string | null
    createdAt: string
    expiresAt: string | null
    _count: RunTraceContextCountAggregateOutputType | null
    _min: RunTraceContextMinAggregateOutputType | null
    _max: RunTraceContextMaxAggregateOutputType | null
  }

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


  export type RunTraceContextSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    traceId?: boolean
    rootSpanId?: boolean
    serviceName?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["runTraceContext"]>

  export type RunTraceContextSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    traceId?: boolean
    rootSpanId?: boolean
    serviceName?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["runTraceContext"]>

  export type RunTraceContextSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    runId?: boolean
    workflowId?: boolean
    traceId?: boolean
    rootSpanId?: boolean
    serviceName?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["runTraceContext"]>

  export type RunTraceContextSelectScalar = {
    runId?: boolean
    workflowId?: boolean
    traceId?: boolean
    rootSpanId?: boolean
    serviceName?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }

  export type RunTraceContextOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"runId" | "workflowId" | "traceId" | "rootSpanId" | "serviceName" | "createdAt" | "expiresAt", ExtArgs["result"]["runTraceContext"]>

  export type $RunTraceContextPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "RunTraceContext"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      runId: string
      workflowId: string
      traceId: string
      rootSpanId: string
      serviceName: string | null
      createdAt: string
      expiresAt: string | null
    }, ExtArgs["result"]["runTraceContext"]>
    composites: {}
  }

  type RunTraceContextGetPayload<S extends boolean | null | undefined | RunTraceContextDefaultArgs> = $Result.GetResult<Prisma.$RunTraceContextPayload, S>

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

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

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

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

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

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

    /**
     * Create a RunTraceContext.
     * @param {RunTraceContextCreateArgs} args - Arguments to create a RunTraceContext.
     * @example
     * // Create one RunTraceContext
     * const RunTraceContext = await prisma.runTraceContext.create({
     *   data: {
     *     // ... data to create a RunTraceContext
     *   }
     * })
     * 
     */
    create<T extends RunTraceContextCreateArgs>(args: SelectSubset<T, RunTraceContextCreateArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many RunTraceContexts and returns the data saved in the database.
     * @param {RunTraceContextCreateManyAndReturnArgs} args - Arguments to create many RunTraceContexts.
     * @example
     * // Create many RunTraceContexts
     * const runTraceContext = await prisma.runTraceContext.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many RunTraceContexts and only return the `runId`
     * const runTraceContextWithRunIdOnly = await prisma.runTraceContext.createManyAndReturn({
     *   select: { runId: 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 RunTraceContextCreateManyAndReturnArgs>(args?: SelectSubset<T, RunTraceContextCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a RunTraceContext.
     * @param {RunTraceContextDeleteArgs} args - Arguments to delete one RunTraceContext.
     * @example
     * // Delete one RunTraceContext
     * const RunTraceContext = await prisma.runTraceContext.delete({
     *   where: {
     *     // ... filter to delete one RunTraceContext
     *   }
     * })
     * 
     */
    delete<T extends RunTraceContextDeleteArgs>(args: SelectSubset<T, RunTraceContextDeleteArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the RunTraceContext model
   */
  interface RunTraceContextFieldRefs {
    readonly runId: FieldRef<"RunTraceContext", 'String'>
    readonly workflowId: FieldRef<"RunTraceContext", 'String'>
    readonly traceId: FieldRef<"RunTraceContext", 'String'>
    readonly rootSpanId: FieldRef<"RunTraceContext", 'String'>
    readonly serviceName: FieldRef<"RunTraceContext", 'String'>
    readonly createdAt: FieldRef<"RunTraceContext", 'String'>
    readonly expiresAt: FieldRef<"RunTraceContext", 'String'>
  }
    

  // Custom InputTypes
  /**
   * RunTraceContext findUnique
   */
  export type RunTraceContextFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * Filter, which RunTraceContext to fetch.
     */
    where: RunTraceContextWhereUniqueInput
  }

  /**
   * RunTraceContext findUniqueOrThrow
   */
  export type RunTraceContextFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * Filter, which RunTraceContext to fetch.
     */
    where: RunTraceContextWhereUniqueInput
  }

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

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

  /**
   * RunTraceContext findMany
   */
  export type RunTraceContextFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * Filter, which RunTraceContexts to fetch.
     */
    where?: RunTraceContextWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of RunTraceContexts to fetch.
     */
    orderBy?: RunTraceContextOrderByWithRelationInput | RunTraceContextOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing RunTraceContexts.
     */
    cursor?: RunTraceContextWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` RunTraceContexts 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` RunTraceContexts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of RunTraceContexts.
     */
    distinct?: RunTraceContextScalarFieldEnum | RunTraceContextScalarFieldEnum[]
  }

  /**
   * RunTraceContext create
   */
  export type RunTraceContextCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * The data needed to create a RunTraceContext.
     */
    data: XOR<RunTraceContextCreateInput, RunTraceContextUncheckedCreateInput>
  }

  /**
   * RunTraceContext createMany
   */
  export type RunTraceContextCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many RunTraceContexts.
     */
    data: RunTraceContextCreateManyInput | RunTraceContextCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * RunTraceContext createManyAndReturn
   */
  export type RunTraceContextCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * The data used to create many RunTraceContexts.
     */
    data: RunTraceContextCreateManyInput | RunTraceContextCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * RunTraceContext update
   */
  export type RunTraceContextUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * The data needed to update a RunTraceContext.
     */
    data: XOR<RunTraceContextUpdateInput, RunTraceContextUncheckedUpdateInput>
    /**
     * Choose, which RunTraceContext to update.
     */
    where: RunTraceContextWhereUniqueInput
  }

  /**
   * RunTraceContext updateMany
   */
  export type RunTraceContextUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update RunTraceContexts.
     */
    data: XOR<RunTraceContextUpdateManyMutationInput, RunTraceContextUncheckedUpdateManyInput>
    /**
     * Filter which RunTraceContexts to update
     */
    where?: RunTraceContextWhereInput
    /**
     * Limit how many RunTraceContexts to update.
     */
    limit?: number
  }

  /**
   * RunTraceContext updateManyAndReturn
   */
  export type RunTraceContextUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * The data used to update RunTraceContexts.
     */
    data: XOR<RunTraceContextUpdateManyMutationInput, RunTraceContextUncheckedUpdateManyInput>
    /**
     * Filter which RunTraceContexts to update
     */
    where?: RunTraceContextWhereInput
    /**
     * Limit how many RunTraceContexts to update.
     */
    limit?: number
  }

  /**
   * RunTraceContext upsert
   */
  export type RunTraceContextUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * The filter to search for the RunTraceContext to update in case it exists.
     */
    where: RunTraceContextWhereUniqueInput
    /**
     * In case the RunTraceContext found by the `where` argument doesn't exist, create a new RunTraceContext with this data.
     */
    create: XOR<RunTraceContextCreateInput, RunTraceContextUncheckedCreateInput>
    /**
     * In case the RunTraceContext was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RunTraceContextUpdateInput, RunTraceContextUncheckedUpdateInput>
  }

  /**
   * RunTraceContext delete
   */
  export type RunTraceContextDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RunTraceContext
     */
    select?: RunTraceContextSelect<ExtArgs> | null
    /**
     * Omit specific fields from the RunTraceContext
     */
    omit?: RunTraceContextOmit<ExtArgs> | null
    /**
     * Filter which RunTraceContext to delete.
     */
    where: RunTraceContextWhereUniqueInput
  }

  /**
   * RunTraceContext deleteMany
   */
  export type RunTraceContextDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which RunTraceContexts to delete
     */
    where?: RunTraceContextWhereInput
    /**
     * Limit how many RunTraceContexts to delete.
     */
    limit?: number
  }

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


  /**
   * Model TelemetrySpan
   */

  export type AggregateTelemetrySpan = {
    _count: TelemetrySpanCountAggregateOutputType | null
    _avg: TelemetrySpanAvgAggregateOutputType | null
    _sum: TelemetrySpanSumAggregateOutputType | null
    _min: TelemetrySpanMinAggregateOutputType | null
    _max: TelemetrySpanMaxAggregateOutputType | null
  }

  export type TelemetrySpanAvgAggregateOutputType = {
    itemIndex: number | null
  }

  export type TelemetrySpanSumAggregateOutputType = {
    itemIndex: number | null
  }

  export type TelemetrySpanMinAggregateOutputType = {
    telemetrySpanId: string | null
    traceId: string | null
    spanId: string | null
    parentSpanId: string | null
    runId: string | null
    workflowId: string | null
    nodeId: string | null
    activationId: string | null
    connectionInvocationId: string | null
    name: string | null
    kind: string | null
    status: string | null
    statusMessage: string | null
    startTime: string | null
    endTime: string | null
    workflowFolder: string | null
    nodeType: string | null
    nodeRole: string | null
    modelName: string | null
    attributesJson: string | null
    eventsJson: string | null
    retentionExpiresAt: string | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    updatedAt: string | null
  }

  export type TelemetrySpanMaxAggregateOutputType = {
    telemetrySpanId: string | null
    traceId: string | null
    spanId: string | null
    parentSpanId: string | null
    runId: string | null
    workflowId: string | null
    nodeId: string | null
    activationId: string | null
    connectionInvocationId: string | null
    name: string | null
    kind: string | null
    status: string | null
    statusMessage: string | null
    startTime: string | null
    endTime: string | null
    workflowFolder: string | null
    nodeType: string | null
    nodeRole: string | null
    modelName: string | null
    attributesJson: string | null
    eventsJson: string | null
    retentionExpiresAt: string | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    updatedAt: string | null
  }

  export type TelemetrySpanCountAggregateOutputType = {
    telemetrySpanId: number
    traceId: number
    spanId: number
    parentSpanId: number
    runId: number
    workflowId: number
    nodeId: number
    activationId: number
    connectionInvocationId: number
    name: number
    kind: number
    status: number
    statusMessage: number
    startTime: number
    endTime: number
    workflowFolder: number
    nodeType: number
    nodeRole: number
    modelName: number
    attributesJson: number
    eventsJson: number
    retentionExpiresAt: number
    iterationId: number
    itemIndex: number
    parentInvocationId: number
    updatedAt: number
    _all: number
  }


  export type TelemetrySpanAvgAggregateInputType = {
    itemIndex?: true
  }

  export type TelemetrySpanSumAggregateInputType = {
    itemIndex?: true
  }

  export type TelemetrySpanMinAggregateInputType = {
    telemetrySpanId?: true
    traceId?: true
    spanId?: true
    parentSpanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    connectionInvocationId?: true
    name?: true
    kind?: true
    status?: true
    statusMessage?: true
    startTime?: true
    endTime?: true
    workflowFolder?: true
    nodeType?: true
    nodeRole?: true
    modelName?: true
    attributesJson?: true
    eventsJson?: true
    retentionExpiresAt?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    updatedAt?: true
  }

  export type TelemetrySpanMaxAggregateInputType = {
    telemetrySpanId?: true
    traceId?: true
    spanId?: true
    parentSpanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    connectionInvocationId?: true
    name?: true
    kind?: true
    status?: true
    statusMessage?: true
    startTime?: true
    endTime?: true
    workflowFolder?: true
    nodeType?: true
    nodeRole?: true
    modelName?: true
    attributesJson?: true
    eventsJson?: true
    retentionExpiresAt?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    updatedAt?: true
  }

  export type TelemetrySpanCountAggregateInputType = {
    telemetrySpanId?: true
    traceId?: true
    spanId?: true
    parentSpanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    connectionInvocationId?: true
    name?: true
    kind?: true
    status?: true
    statusMessage?: true
    startTime?: true
    endTime?: true
    workflowFolder?: true
    nodeType?: true
    nodeRole?: true
    modelName?: true
    attributesJson?: true
    eventsJson?: true
    retentionExpiresAt?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    updatedAt?: true
    _all?: true
  }

  export type TelemetrySpanAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TelemetrySpan to aggregate.
     */
    where?: TelemetrySpanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TelemetrySpans to fetch.
     */
    orderBy?: TelemetrySpanOrderByWithRelationInput | TelemetrySpanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TelemetrySpanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TelemetrySpans 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` TelemetrySpans.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TelemetrySpans
    **/
    _count?: true | TelemetrySpanCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TelemetrySpanAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TelemetrySpanSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TelemetrySpanMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TelemetrySpanMaxAggregateInputType
  }

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




  export type TelemetrySpanGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TelemetrySpanWhereInput
    orderBy?: TelemetrySpanOrderByWithAggregationInput | TelemetrySpanOrderByWithAggregationInput[]
    by: TelemetrySpanScalarFieldEnum[] | TelemetrySpanScalarFieldEnum
    having?: TelemetrySpanScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TelemetrySpanCountAggregateInputType | true
    _avg?: TelemetrySpanAvgAggregateInputType
    _sum?: TelemetrySpanSumAggregateInputType
    _min?: TelemetrySpanMinAggregateInputType
    _max?: TelemetrySpanMaxAggregateInputType
  }

  export type TelemetrySpanGroupByOutputType = {
    telemetrySpanId: string
    traceId: string
    spanId: string
    parentSpanId: string | null
    runId: string
    workflowId: string
    nodeId: string | null
    activationId: string | null
    connectionInvocationId: string | null
    name: string
    kind: string
    status: string | null
    statusMessage: string | null
    startTime: string | null
    endTime: string | null
    workflowFolder: string | null
    nodeType: string | null
    nodeRole: string | null
    modelName: string | null
    attributesJson: string | null
    eventsJson: string | null
    retentionExpiresAt: string | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    updatedAt: string
    _count: TelemetrySpanCountAggregateOutputType | null
    _avg: TelemetrySpanAvgAggregateOutputType | null
    _sum: TelemetrySpanSumAggregateOutputType | null
    _min: TelemetrySpanMinAggregateOutputType | null
    _max: TelemetrySpanMaxAggregateOutputType | null
  }

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


  export type TelemetrySpanSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    telemetrySpanId?: boolean
    traceId?: boolean
    spanId?: boolean
    parentSpanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    connectionInvocationId?: boolean
    name?: boolean
    kind?: boolean
    status?: boolean
    statusMessage?: boolean
    startTime?: boolean
    endTime?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    attributesJson?: boolean
    eventsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["telemetrySpan"]>

  export type TelemetrySpanSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    telemetrySpanId?: boolean
    traceId?: boolean
    spanId?: boolean
    parentSpanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    connectionInvocationId?: boolean
    name?: boolean
    kind?: boolean
    status?: boolean
    statusMessage?: boolean
    startTime?: boolean
    endTime?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    attributesJson?: boolean
    eventsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["telemetrySpan"]>

  export type TelemetrySpanSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    telemetrySpanId?: boolean
    traceId?: boolean
    spanId?: boolean
    parentSpanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    connectionInvocationId?: boolean
    name?: boolean
    kind?: boolean
    status?: boolean
    statusMessage?: boolean
    startTime?: boolean
    endTime?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    attributesJson?: boolean
    eventsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["telemetrySpan"]>

  export type TelemetrySpanSelectScalar = {
    telemetrySpanId?: boolean
    traceId?: boolean
    spanId?: boolean
    parentSpanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    connectionInvocationId?: boolean
    name?: boolean
    kind?: boolean
    status?: boolean
    statusMessage?: boolean
    startTime?: boolean
    endTime?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    attributesJson?: boolean
    eventsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
    updatedAt?: boolean
  }

  export type TelemetrySpanOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"telemetrySpanId" | "traceId" | "spanId" | "parentSpanId" | "runId" | "workflowId" | "nodeId" | "activationId" | "connectionInvocationId" | "name" | "kind" | "status" | "statusMessage" | "startTime" | "endTime" | "workflowFolder" | "nodeType" | "nodeRole" | "modelName" | "attributesJson" | "eventsJson" | "retentionExpiresAt" | "iterationId" | "itemIndex" | "parentInvocationId" | "updatedAt", ExtArgs["result"]["telemetrySpan"]>

  export type $TelemetrySpanPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TelemetrySpan"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      telemetrySpanId: string
      traceId: string
      spanId: string
      parentSpanId: string | null
      runId: string
      workflowId: string
      nodeId: string | null
      activationId: string | null
      connectionInvocationId: string | null
      name: string
      kind: string
      status: string | null
      statusMessage: string | null
      startTime: string | null
      endTime: string | null
      workflowFolder: string | null
      nodeType: string | null
      nodeRole: string | null
      modelName: string | null
      attributesJson: string | null
      eventsJson: string | null
      retentionExpiresAt: string | null
      iterationId: string | null
      itemIndex: number | null
      parentInvocationId: string | null
      updatedAt: string
    }, ExtArgs["result"]["telemetrySpan"]>
    composites: {}
  }

  type TelemetrySpanGetPayload<S extends boolean | null | undefined | TelemetrySpanDefaultArgs> = $Result.GetResult<Prisma.$TelemetrySpanPayload, S>

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

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

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

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

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

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

    /**
     * Create a TelemetrySpan.
     * @param {TelemetrySpanCreateArgs} args - Arguments to create a TelemetrySpan.
     * @example
     * // Create one TelemetrySpan
     * const TelemetrySpan = await prisma.telemetrySpan.create({
     *   data: {
     *     // ... data to create a TelemetrySpan
     *   }
     * })
     * 
     */
    create<T extends TelemetrySpanCreateArgs>(args: SelectSubset<T, TelemetrySpanCreateArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TelemetrySpans and returns the data saved in the database.
     * @param {TelemetrySpanCreateManyAndReturnArgs} args - Arguments to create many TelemetrySpans.
     * @example
     * // Create many TelemetrySpans
     * const telemetrySpan = await prisma.telemetrySpan.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TelemetrySpans and only return the `telemetrySpanId`
     * const telemetrySpanWithTelemetrySpanIdOnly = await prisma.telemetrySpan.createManyAndReturn({
     *   select: { telemetrySpanId: 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 TelemetrySpanCreateManyAndReturnArgs>(args?: SelectSubset<T, TelemetrySpanCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TelemetrySpan.
     * @param {TelemetrySpanDeleteArgs} args - Arguments to delete one TelemetrySpan.
     * @example
     * // Delete one TelemetrySpan
     * const TelemetrySpan = await prisma.telemetrySpan.delete({
     *   where: {
     *     // ... filter to delete one TelemetrySpan
     *   }
     * })
     * 
     */
    delete<T extends TelemetrySpanDeleteArgs>(args: SelectSubset<T, TelemetrySpanDeleteArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the TelemetrySpan model
   */
  interface TelemetrySpanFieldRefs {
    readonly telemetrySpanId: FieldRef<"TelemetrySpan", 'String'>
    readonly traceId: FieldRef<"TelemetrySpan", 'String'>
    readonly spanId: FieldRef<"TelemetrySpan", 'String'>
    readonly parentSpanId: FieldRef<"TelemetrySpan", 'String'>
    readonly runId: FieldRef<"TelemetrySpan", 'String'>
    readonly workflowId: FieldRef<"TelemetrySpan", 'String'>
    readonly nodeId: FieldRef<"TelemetrySpan", 'String'>
    readonly activationId: FieldRef<"TelemetrySpan", 'String'>
    readonly connectionInvocationId: FieldRef<"TelemetrySpan", 'String'>
    readonly name: FieldRef<"TelemetrySpan", 'String'>
    readonly kind: FieldRef<"TelemetrySpan", 'String'>
    readonly status: FieldRef<"TelemetrySpan", 'String'>
    readonly statusMessage: FieldRef<"TelemetrySpan", 'String'>
    readonly startTime: FieldRef<"TelemetrySpan", 'String'>
    readonly endTime: FieldRef<"TelemetrySpan", 'String'>
    readonly workflowFolder: FieldRef<"TelemetrySpan", 'String'>
    readonly nodeType: FieldRef<"TelemetrySpan", 'String'>
    readonly nodeRole: FieldRef<"TelemetrySpan", 'String'>
    readonly modelName: FieldRef<"TelemetrySpan", 'String'>
    readonly attributesJson: FieldRef<"TelemetrySpan", 'String'>
    readonly eventsJson: FieldRef<"TelemetrySpan", 'String'>
    readonly retentionExpiresAt: FieldRef<"TelemetrySpan", 'String'>
    readonly iterationId: FieldRef<"TelemetrySpan", 'String'>
    readonly itemIndex: FieldRef<"TelemetrySpan", 'Int'>
    readonly parentInvocationId: FieldRef<"TelemetrySpan", 'String'>
    readonly updatedAt: FieldRef<"TelemetrySpan", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TelemetrySpan findUnique
   */
  export type TelemetrySpanFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * Filter, which TelemetrySpan to fetch.
     */
    where: TelemetrySpanWhereUniqueInput
  }

  /**
   * TelemetrySpan findUniqueOrThrow
   */
  export type TelemetrySpanFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * Filter, which TelemetrySpan to fetch.
     */
    where: TelemetrySpanWhereUniqueInput
  }

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

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

  /**
   * TelemetrySpan findMany
   */
  export type TelemetrySpanFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * Filter, which TelemetrySpans to fetch.
     */
    where?: TelemetrySpanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TelemetrySpans to fetch.
     */
    orderBy?: TelemetrySpanOrderByWithRelationInput | TelemetrySpanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TelemetrySpans.
     */
    cursor?: TelemetrySpanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TelemetrySpans 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` TelemetrySpans.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TelemetrySpans.
     */
    distinct?: TelemetrySpanScalarFieldEnum | TelemetrySpanScalarFieldEnum[]
  }

  /**
   * TelemetrySpan create
   */
  export type TelemetrySpanCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * The data needed to create a TelemetrySpan.
     */
    data: XOR<TelemetrySpanCreateInput, TelemetrySpanUncheckedCreateInput>
  }

  /**
   * TelemetrySpan createMany
   */
  export type TelemetrySpanCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TelemetrySpans.
     */
    data: TelemetrySpanCreateManyInput | TelemetrySpanCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TelemetrySpan createManyAndReturn
   */
  export type TelemetrySpanCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * The data used to create many TelemetrySpans.
     */
    data: TelemetrySpanCreateManyInput | TelemetrySpanCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TelemetrySpan update
   */
  export type TelemetrySpanUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * The data needed to update a TelemetrySpan.
     */
    data: XOR<TelemetrySpanUpdateInput, TelemetrySpanUncheckedUpdateInput>
    /**
     * Choose, which TelemetrySpan to update.
     */
    where: TelemetrySpanWhereUniqueInput
  }

  /**
   * TelemetrySpan updateMany
   */
  export type TelemetrySpanUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TelemetrySpans.
     */
    data: XOR<TelemetrySpanUpdateManyMutationInput, TelemetrySpanUncheckedUpdateManyInput>
    /**
     * Filter which TelemetrySpans to update
     */
    where?: TelemetrySpanWhereInput
    /**
     * Limit how many TelemetrySpans to update.
     */
    limit?: number
  }

  /**
   * TelemetrySpan updateManyAndReturn
   */
  export type TelemetrySpanUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * The data used to update TelemetrySpans.
     */
    data: XOR<TelemetrySpanUpdateManyMutationInput, TelemetrySpanUncheckedUpdateManyInput>
    /**
     * Filter which TelemetrySpans to update
     */
    where?: TelemetrySpanWhereInput
    /**
     * Limit how many TelemetrySpans to update.
     */
    limit?: number
  }

  /**
   * TelemetrySpan upsert
   */
  export type TelemetrySpanUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * The filter to search for the TelemetrySpan to update in case it exists.
     */
    where: TelemetrySpanWhereUniqueInput
    /**
     * In case the TelemetrySpan found by the `where` argument doesn't exist, create a new TelemetrySpan with this data.
     */
    create: XOR<TelemetrySpanCreateInput, TelemetrySpanUncheckedCreateInput>
    /**
     * In case the TelemetrySpan was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TelemetrySpanUpdateInput, TelemetrySpanUncheckedUpdateInput>
  }

  /**
   * TelemetrySpan delete
   */
  export type TelemetrySpanDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetrySpan
     */
    select?: TelemetrySpanSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetrySpan
     */
    omit?: TelemetrySpanOmit<ExtArgs> | null
    /**
     * Filter which TelemetrySpan to delete.
     */
    where: TelemetrySpanWhereUniqueInput
  }

  /**
   * TelemetrySpan deleteMany
   */
  export type TelemetrySpanDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TelemetrySpans to delete
     */
    where?: TelemetrySpanWhereInput
    /**
     * Limit how many TelemetrySpans to delete.
     */
    limit?: number
  }

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


  /**
   * Model WorkflowSnapshot
   */

  export type AggregateWorkflowSnapshot = {
    _count: WorkflowSnapshotCountAggregateOutputType | null
    _min: WorkflowSnapshotMinAggregateOutputType | null
    _max: WorkflowSnapshotMaxAggregateOutputType | null
  }

  export type WorkflowSnapshotMinAggregateOutputType = {
    id: string | null
    workflowId: string | null
    snapshotHash: string | null
    snapshotJson: string | null
    createdAt: string | null
  }

  export type WorkflowSnapshotMaxAggregateOutputType = {
    id: string | null
    workflowId: string | null
    snapshotHash: string | null
    snapshotJson: string | null
    createdAt: string | null
  }

  export type WorkflowSnapshotCountAggregateOutputType = {
    id: number
    workflowId: number
    snapshotHash: number
    snapshotJson: number
    createdAt: number
    _all: number
  }


  export type WorkflowSnapshotMinAggregateInputType = {
    id?: true
    workflowId?: true
    snapshotHash?: true
    snapshotJson?: true
    createdAt?: true
  }

  export type WorkflowSnapshotMaxAggregateInputType = {
    id?: true
    workflowId?: true
    snapshotHash?: true
    snapshotJson?: true
    createdAt?: true
  }

  export type WorkflowSnapshotCountAggregateInputType = {
    id?: true
    workflowId?: true
    snapshotHash?: true
    snapshotJson?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type WorkflowSnapshotGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WorkflowSnapshotWhereInput
    orderBy?: WorkflowSnapshotOrderByWithAggregationInput | WorkflowSnapshotOrderByWithAggregationInput[]
    by: WorkflowSnapshotScalarFieldEnum[] | WorkflowSnapshotScalarFieldEnum
    having?: WorkflowSnapshotScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WorkflowSnapshotCountAggregateInputType | true
    _min?: WorkflowSnapshotMinAggregateInputType
    _max?: WorkflowSnapshotMaxAggregateInputType
  }

  export type WorkflowSnapshotGroupByOutputType = {
    id: string
    workflowId: string
    snapshotHash: string
    snapshotJson: string
    createdAt: string
    _count: WorkflowSnapshotCountAggregateOutputType | null
    _min: WorkflowSnapshotMinAggregateOutputType | null
    _max: WorkflowSnapshotMaxAggregateOutputType | null
  }

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


  export type WorkflowSnapshotSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    workflowId?: boolean
    snapshotHash?: boolean
    snapshotJson?: boolean
    createdAt?: boolean
    runs?: boolean | WorkflowSnapshot$runsArgs<ExtArgs>
    _count?: boolean | WorkflowSnapshotCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["workflowSnapshot"]>

  export type WorkflowSnapshotSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    workflowId?: boolean
    snapshotHash?: boolean
    snapshotJson?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["workflowSnapshot"]>

  export type WorkflowSnapshotSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    workflowId?: boolean
    snapshotHash?: boolean
    snapshotJson?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["workflowSnapshot"]>

  export type WorkflowSnapshotSelectScalar = {
    id?: boolean
    workflowId?: boolean
    snapshotHash?: boolean
    snapshotJson?: boolean
    createdAt?: boolean
  }

  export type WorkflowSnapshotOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "workflowId" | "snapshotHash" | "snapshotJson" | "createdAt", ExtArgs["result"]["workflowSnapshot"]>
  export type WorkflowSnapshotInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    runs?: boolean | WorkflowSnapshot$runsArgs<ExtArgs>
    _count?: boolean | WorkflowSnapshotCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type WorkflowSnapshotIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type WorkflowSnapshotIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $WorkflowSnapshotPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WorkflowSnapshot"
    objects: {
      runs: Prisma.$RunPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      workflowId: string
      /**
       * SHA-256 hex digest of snapshotJson — dedup key: same workflow content → one row.
       */
      snapshotHash: string
      snapshotJson: string
      createdAt: string
    }, ExtArgs["result"]["workflowSnapshot"]>
    composites: {}
  }

  type WorkflowSnapshotGetPayload<S extends boolean | null | undefined | WorkflowSnapshotDefaultArgs> = $Result.GetResult<Prisma.$WorkflowSnapshotPayload, S>

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

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

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

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

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

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

    /**
     * Create a WorkflowSnapshot.
     * @param {WorkflowSnapshotCreateArgs} args - Arguments to create a WorkflowSnapshot.
     * @example
     * // Create one WorkflowSnapshot
     * const WorkflowSnapshot = await prisma.workflowSnapshot.create({
     *   data: {
     *     // ... data to create a WorkflowSnapshot
     *   }
     * })
     * 
     */
    create<T extends WorkflowSnapshotCreateArgs>(args: SelectSubset<T, WorkflowSnapshotCreateArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many WorkflowSnapshots and returns the data saved in the database.
     * @param {WorkflowSnapshotCreateManyAndReturnArgs} args - Arguments to create many WorkflowSnapshots.
     * @example
     * // Create many WorkflowSnapshots
     * const workflowSnapshot = await prisma.workflowSnapshot.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many WorkflowSnapshots and only return the `id`
     * const workflowSnapshotWithIdOnly = await prisma.workflowSnapshot.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 WorkflowSnapshotCreateManyAndReturnArgs>(args?: SelectSubset<T, WorkflowSnapshotCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a WorkflowSnapshot.
     * @param {WorkflowSnapshotDeleteArgs} args - Arguments to delete one WorkflowSnapshot.
     * @example
     * // Delete one WorkflowSnapshot
     * const WorkflowSnapshot = await prisma.workflowSnapshot.delete({
     *   where: {
     *     // ... filter to delete one WorkflowSnapshot
     *   }
     * })
     * 
     */
    delete<T extends WorkflowSnapshotDeleteArgs>(args: SelectSubset<T, WorkflowSnapshotDeleteArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the WorkflowSnapshot model
   */
  interface WorkflowSnapshotFieldRefs {
    readonly id: FieldRef<"WorkflowSnapshot", 'String'>
    readonly workflowId: FieldRef<"WorkflowSnapshot", 'String'>
    readonly snapshotHash: FieldRef<"WorkflowSnapshot", 'String'>
    readonly snapshotJson: FieldRef<"WorkflowSnapshot", 'String'>
    readonly createdAt: FieldRef<"WorkflowSnapshot", 'String'>
  }
    

  // Custom InputTypes
  /**
   * WorkflowSnapshot findUnique
   */
  export type WorkflowSnapshotFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * Filter, which WorkflowSnapshot to fetch.
     */
    where: WorkflowSnapshotWhereUniqueInput
  }

  /**
   * WorkflowSnapshot findUniqueOrThrow
   */
  export type WorkflowSnapshotFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * Filter, which WorkflowSnapshot to fetch.
     */
    where: WorkflowSnapshotWhereUniqueInput
  }

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

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

  /**
   * WorkflowSnapshot findMany
   */
  export type WorkflowSnapshotFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * Filter, which WorkflowSnapshots to fetch.
     */
    where?: WorkflowSnapshotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WorkflowSnapshots to fetch.
     */
    orderBy?: WorkflowSnapshotOrderByWithRelationInput | WorkflowSnapshotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WorkflowSnapshots.
     */
    cursor?: WorkflowSnapshotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WorkflowSnapshots 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` WorkflowSnapshots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of WorkflowSnapshots.
     */
    distinct?: WorkflowSnapshotScalarFieldEnum | WorkflowSnapshotScalarFieldEnum[]
  }

  /**
   * WorkflowSnapshot create
   */
  export type WorkflowSnapshotCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * The data needed to create a WorkflowSnapshot.
     */
    data: XOR<WorkflowSnapshotCreateInput, WorkflowSnapshotUncheckedCreateInput>
  }

  /**
   * WorkflowSnapshot createMany
   */
  export type WorkflowSnapshotCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many WorkflowSnapshots.
     */
    data: WorkflowSnapshotCreateManyInput | WorkflowSnapshotCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowSnapshot createManyAndReturn
   */
  export type WorkflowSnapshotCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * The data used to create many WorkflowSnapshots.
     */
    data: WorkflowSnapshotCreateManyInput | WorkflowSnapshotCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowSnapshot update
   */
  export type WorkflowSnapshotUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * The data needed to update a WorkflowSnapshot.
     */
    data: XOR<WorkflowSnapshotUpdateInput, WorkflowSnapshotUncheckedUpdateInput>
    /**
     * Choose, which WorkflowSnapshot to update.
     */
    where: WorkflowSnapshotWhereUniqueInput
  }

  /**
   * WorkflowSnapshot updateMany
   */
  export type WorkflowSnapshotUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WorkflowSnapshots.
     */
    data: XOR<WorkflowSnapshotUpdateManyMutationInput, WorkflowSnapshotUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowSnapshots to update
     */
    where?: WorkflowSnapshotWhereInput
    /**
     * Limit how many WorkflowSnapshots to update.
     */
    limit?: number
  }

  /**
   * WorkflowSnapshot updateManyAndReturn
   */
  export type WorkflowSnapshotUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * The data used to update WorkflowSnapshots.
     */
    data: XOR<WorkflowSnapshotUpdateManyMutationInput, WorkflowSnapshotUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowSnapshots to update
     */
    where?: WorkflowSnapshotWhereInput
    /**
     * Limit how many WorkflowSnapshots to update.
     */
    limit?: number
  }

  /**
   * WorkflowSnapshot upsert
   */
  export type WorkflowSnapshotUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * The filter to search for the WorkflowSnapshot to update in case it exists.
     */
    where: WorkflowSnapshotWhereUniqueInput
    /**
     * In case the WorkflowSnapshot found by the `where` argument doesn't exist, create a new WorkflowSnapshot with this data.
     */
    create: XOR<WorkflowSnapshotCreateInput, WorkflowSnapshotUncheckedCreateInput>
    /**
     * In case the WorkflowSnapshot was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WorkflowSnapshotUpdateInput, WorkflowSnapshotUncheckedUpdateInput>
  }

  /**
   * WorkflowSnapshot delete
   */
  export type WorkflowSnapshotDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowSnapshot
     */
    select?: WorkflowSnapshotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowSnapshot
     */
    omit?: WorkflowSnapshotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkflowSnapshotInclude<ExtArgs> | null
    /**
     * Filter which WorkflowSnapshot to delete.
     */
    where: WorkflowSnapshotWhereUniqueInput
  }

  /**
   * WorkflowSnapshot deleteMany
   */
  export type WorkflowSnapshotDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WorkflowSnapshots to delete
     */
    where?: WorkflowSnapshotWhereInput
    /**
     * Limit how many WorkflowSnapshots to delete.
     */
    limit?: number
  }

  /**
   * WorkflowSnapshot.runs
   */
  export type WorkflowSnapshot$runsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Run
     */
    select?: RunSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Run
     */
    omit?: RunOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RunInclude<ExtArgs> | null
    where?: RunWhereInput
    orderBy?: RunOrderByWithRelationInput | RunOrderByWithRelationInput[]
    cursor?: RunWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RunScalarFieldEnum | RunScalarFieldEnum[]
  }

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


  /**
   * Model TelemetryArtifact
   */

  export type AggregateTelemetryArtifact = {
    _count: TelemetryArtifactCountAggregateOutputType | null
    _avg: TelemetryArtifactAvgAggregateOutputType | null
    _sum: TelemetryArtifactSumAggregateOutputType | null
    _min: TelemetryArtifactMinAggregateOutputType | null
    _max: TelemetryArtifactMaxAggregateOutputType | null
  }

  export type TelemetryArtifactAvgAggregateOutputType = {
    bytes: number | null
  }

  export type TelemetryArtifactSumAggregateOutputType = {
    bytes: number | null
  }

  export type TelemetryArtifactMinAggregateOutputType = {
    artifactId: string | null
    traceId: string | null
    spanId: string | null
    runId: string | null
    workflowId: string | null
    nodeId: string | null
    activationId: string | null
    kind: string | null
    contentType: string | null
    previewText: string | null
    previewJson: string | null
    payloadText: string | null
    payloadJson: string | null
    payloadStorageKey: string | null
    bytes: number | null
    truncated: boolean | null
    createdAt: string | null
    expiresAt: string | null
    retentionExpiresAt: string | null
  }

  export type TelemetryArtifactMaxAggregateOutputType = {
    artifactId: string | null
    traceId: string | null
    spanId: string | null
    runId: string | null
    workflowId: string | null
    nodeId: string | null
    activationId: string | null
    kind: string | null
    contentType: string | null
    previewText: string | null
    previewJson: string | null
    payloadText: string | null
    payloadJson: string | null
    payloadStorageKey: string | null
    bytes: number | null
    truncated: boolean | null
    createdAt: string | null
    expiresAt: string | null
    retentionExpiresAt: string | null
  }

  export type TelemetryArtifactCountAggregateOutputType = {
    artifactId: number
    traceId: number
    spanId: number
    runId: number
    workflowId: number
    nodeId: number
    activationId: number
    kind: number
    contentType: number
    previewText: number
    previewJson: number
    payloadText: number
    payloadJson: number
    payloadStorageKey: number
    bytes: number
    truncated: number
    createdAt: number
    expiresAt: number
    retentionExpiresAt: number
    _all: number
  }


  export type TelemetryArtifactAvgAggregateInputType = {
    bytes?: true
  }

  export type TelemetryArtifactSumAggregateInputType = {
    bytes?: true
  }

  export type TelemetryArtifactMinAggregateInputType = {
    artifactId?: true
    traceId?: true
    spanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    kind?: true
    contentType?: true
    previewText?: true
    previewJson?: true
    payloadText?: true
    payloadJson?: true
    payloadStorageKey?: true
    bytes?: true
    truncated?: true
    createdAt?: true
    expiresAt?: true
    retentionExpiresAt?: true
  }

  export type TelemetryArtifactMaxAggregateInputType = {
    artifactId?: true
    traceId?: true
    spanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    kind?: true
    contentType?: true
    previewText?: true
    previewJson?: true
    payloadText?: true
    payloadJson?: true
    payloadStorageKey?: true
    bytes?: true
    truncated?: true
    createdAt?: true
    expiresAt?: true
    retentionExpiresAt?: true
  }

  export type TelemetryArtifactCountAggregateInputType = {
    artifactId?: true
    traceId?: true
    spanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    kind?: true
    contentType?: true
    previewText?: true
    previewJson?: true
    payloadText?: true
    payloadJson?: true
    payloadStorageKey?: true
    bytes?: true
    truncated?: true
    createdAt?: true
    expiresAt?: true
    retentionExpiresAt?: true
    _all?: true
  }

  export type TelemetryArtifactAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TelemetryArtifact to aggregate.
     */
    where?: TelemetryArtifactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TelemetryArtifacts to fetch.
     */
    orderBy?: TelemetryArtifactOrderByWithRelationInput | TelemetryArtifactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TelemetryArtifactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TelemetryArtifacts 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` TelemetryArtifacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TelemetryArtifacts
    **/
    _count?: true | TelemetryArtifactCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TelemetryArtifactAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TelemetryArtifactSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TelemetryArtifactMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TelemetryArtifactMaxAggregateInputType
  }

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




  export type TelemetryArtifactGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TelemetryArtifactWhereInput
    orderBy?: TelemetryArtifactOrderByWithAggregationInput | TelemetryArtifactOrderByWithAggregationInput[]
    by: TelemetryArtifactScalarFieldEnum[] | TelemetryArtifactScalarFieldEnum
    having?: TelemetryArtifactScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TelemetryArtifactCountAggregateInputType | true
    _avg?: TelemetryArtifactAvgAggregateInputType
    _sum?: TelemetryArtifactSumAggregateInputType
    _min?: TelemetryArtifactMinAggregateInputType
    _max?: TelemetryArtifactMaxAggregateInputType
  }

  export type TelemetryArtifactGroupByOutputType = {
    artifactId: string
    traceId: string
    spanId: string
    runId: string
    workflowId: string
    nodeId: string | null
    activationId: string | null
    kind: string
    contentType: string
    previewText: string | null
    previewJson: string | null
    payloadText: string | null
    payloadJson: string | null
    payloadStorageKey: string | null
    bytes: number | null
    truncated: boolean | null
    createdAt: string
    expiresAt: string | null
    retentionExpiresAt: string | null
    _count: TelemetryArtifactCountAggregateOutputType | null
    _avg: TelemetryArtifactAvgAggregateOutputType | null
    _sum: TelemetryArtifactSumAggregateOutputType | null
    _min: TelemetryArtifactMinAggregateOutputType | null
    _max: TelemetryArtifactMaxAggregateOutputType | null
  }

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


  export type TelemetryArtifactSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    artifactId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    kind?: boolean
    contentType?: boolean
    previewText?: boolean
    previewJson?: boolean
    payloadText?: boolean
    payloadJson?: boolean
    payloadStorageKey?: boolean
    bytes?: boolean
    truncated?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    retentionExpiresAt?: boolean
  }, ExtArgs["result"]["telemetryArtifact"]>

  export type TelemetryArtifactSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    artifactId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    kind?: boolean
    contentType?: boolean
    previewText?: boolean
    previewJson?: boolean
    payloadText?: boolean
    payloadJson?: boolean
    payloadStorageKey?: boolean
    bytes?: boolean
    truncated?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    retentionExpiresAt?: boolean
  }, ExtArgs["result"]["telemetryArtifact"]>

  export type TelemetryArtifactSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    artifactId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    kind?: boolean
    contentType?: boolean
    previewText?: boolean
    previewJson?: boolean
    payloadText?: boolean
    payloadJson?: boolean
    payloadStorageKey?: boolean
    bytes?: boolean
    truncated?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    retentionExpiresAt?: boolean
  }, ExtArgs["result"]["telemetryArtifact"]>

  export type TelemetryArtifactSelectScalar = {
    artifactId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    kind?: boolean
    contentType?: boolean
    previewText?: boolean
    previewJson?: boolean
    payloadText?: boolean
    payloadJson?: boolean
    payloadStorageKey?: boolean
    bytes?: boolean
    truncated?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    retentionExpiresAt?: boolean
  }

  export type TelemetryArtifactOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"artifactId" | "traceId" | "spanId" | "runId" | "workflowId" | "nodeId" | "activationId" | "kind" | "contentType" | "previewText" | "previewJson" | "payloadText" | "payloadJson" | "payloadStorageKey" | "bytes" | "truncated" | "createdAt" | "expiresAt" | "retentionExpiresAt", ExtArgs["result"]["telemetryArtifact"]>

  export type $TelemetryArtifactPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TelemetryArtifact"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      artifactId: string
      traceId: string
      spanId: string
      runId: string
      workflowId: string
      nodeId: string | null
      activationId: string | null
      kind: string
      contentType: string
      previewText: string | null
      previewJson: string | null
      payloadText: string | null
      payloadJson: string | null
      payloadStorageKey: string | null
      bytes: number | null
      truncated: boolean | null
      createdAt: string
      expiresAt: string | null
      retentionExpiresAt: string | null
    }, ExtArgs["result"]["telemetryArtifact"]>
    composites: {}
  }

  type TelemetryArtifactGetPayload<S extends boolean | null | undefined | TelemetryArtifactDefaultArgs> = $Result.GetResult<Prisma.$TelemetryArtifactPayload, S>

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

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

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

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

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

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

    /**
     * Create a TelemetryArtifact.
     * @param {TelemetryArtifactCreateArgs} args - Arguments to create a TelemetryArtifact.
     * @example
     * // Create one TelemetryArtifact
     * const TelemetryArtifact = await prisma.telemetryArtifact.create({
     *   data: {
     *     // ... data to create a TelemetryArtifact
     *   }
     * })
     * 
     */
    create<T extends TelemetryArtifactCreateArgs>(args: SelectSubset<T, TelemetryArtifactCreateArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TelemetryArtifacts and returns the data saved in the database.
     * @param {TelemetryArtifactCreateManyAndReturnArgs} args - Arguments to create many TelemetryArtifacts.
     * @example
     * // Create many TelemetryArtifacts
     * const telemetryArtifact = await prisma.telemetryArtifact.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TelemetryArtifacts and only return the `artifactId`
     * const telemetryArtifactWithArtifactIdOnly = await prisma.telemetryArtifact.createManyAndReturn({
     *   select: { artifactId: 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 TelemetryArtifactCreateManyAndReturnArgs>(args?: SelectSubset<T, TelemetryArtifactCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TelemetryArtifact.
     * @param {TelemetryArtifactDeleteArgs} args - Arguments to delete one TelemetryArtifact.
     * @example
     * // Delete one TelemetryArtifact
     * const TelemetryArtifact = await prisma.telemetryArtifact.delete({
     *   where: {
     *     // ... filter to delete one TelemetryArtifact
     *   }
     * })
     * 
     */
    delete<T extends TelemetryArtifactDeleteArgs>(args: SelectSubset<T, TelemetryArtifactDeleteArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the TelemetryArtifact model
   */
  interface TelemetryArtifactFieldRefs {
    readonly artifactId: FieldRef<"TelemetryArtifact", 'String'>
    readonly traceId: FieldRef<"TelemetryArtifact", 'String'>
    readonly spanId: FieldRef<"TelemetryArtifact", 'String'>
    readonly runId: FieldRef<"TelemetryArtifact", 'String'>
    readonly workflowId: FieldRef<"TelemetryArtifact", 'String'>
    readonly nodeId: FieldRef<"TelemetryArtifact", 'String'>
    readonly activationId: FieldRef<"TelemetryArtifact", 'String'>
    readonly kind: FieldRef<"TelemetryArtifact", 'String'>
    readonly contentType: FieldRef<"TelemetryArtifact", 'String'>
    readonly previewText: FieldRef<"TelemetryArtifact", 'String'>
    readonly previewJson: FieldRef<"TelemetryArtifact", 'String'>
    readonly payloadText: FieldRef<"TelemetryArtifact", 'String'>
    readonly payloadJson: FieldRef<"TelemetryArtifact", 'String'>
    readonly payloadStorageKey: FieldRef<"TelemetryArtifact", 'String'>
    readonly bytes: FieldRef<"TelemetryArtifact", 'Int'>
    readonly truncated: FieldRef<"TelemetryArtifact", 'Boolean'>
    readonly createdAt: FieldRef<"TelemetryArtifact", 'String'>
    readonly expiresAt: FieldRef<"TelemetryArtifact", 'String'>
    readonly retentionExpiresAt: FieldRef<"TelemetryArtifact", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TelemetryArtifact findUnique
   */
  export type TelemetryArtifactFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * Filter, which TelemetryArtifact to fetch.
     */
    where: TelemetryArtifactWhereUniqueInput
  }

  /**
   * TelemetryArtifact findUniqueOrThrow
   */
  export type TelemetryArtifactFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * Filter, which TelemetryArtifact to fetch.
     */
    where: TelemetryArtifactWhereUniqueInput
  }

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

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

  /**
   * TelemetryArtifact findMany
   */
  export type TelemetryArtifactFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * Filter, which TelemetryArtifacts to fetch.
     */
    where?: TelemetryArtifactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TelemetryArtifacts to fetch.
     */
    orderBy?: TelemetryArtifactOrderByWithRelationInput | TelemetryArtifactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TelemetryArtifacts.
     */
    cursor?: TelemetryArtifactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TelemetryArtifacts 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` TelemetryArtifacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TelemetryArtifacts.
     */
    distinct?: TelemetryArtifactScalarFieldEnum | TelemetryArtifactScalarFieldEnum[]
  }

  /**
   * TelemetryArtifact create
   */
  export type TelemetryArtifactCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * The data needed to create a TelemetryArtifact.
     */
    data: XOR<TelemetryArtifactCreateInput, TelemetryArtifactUncheckedCreateInput>
  }

  /**
   * TelemetryArtifact createMany
   */
  export type TelemetryArtifactCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TelemetryArtifacts.
     */
    data: TelemetryArtifactCreateManyInput | TelemetryArtifactCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TelemetryArtifact createManyAndReturn
   */
  export type TelemetryArtifactCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * The data used to create many TelemetryArtifacts.
     */
    data: TelemetryArtifactCreateManyInput | TelemetryArtifactCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TelemetryArtifact update
   */
  export type TelemetryArtifactUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * The data needed to update a TelemetryArtifact.
     */
    data: XOR<TelemetryArtifactUpdateInput, TelemetryArtifactUncheckedUpdateInput>
    /**
     * Choose, which TelemetryArtifact to update.
     */
    where: TelemetryArtifactWhereUniqueInput
  }

  /**
   * TelemetryArtifact updateMany
   */
  export type TelemetryArtifactUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TelemetryArtifacts.
     */
    data: XOR<TelemetryArtifactUpdateManyMutationInput, TelemetryArtifactUncheckedUpdateManyInput>
    /**
     * Filter which TelemetryArtifacts to update
     */
    where?: TelemetryArtifactWhereInput
    /**
     * Limit how many TelemetryArtifacts to update.
     */
    limit?: number
  }

  /**
   * TelemetryArtifact updateManyAndReturn
   */
  export type TelemetryArtifactUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * The data used to update TelemetryArtifacts.
     */
    data: XOR<TelemetryArtifactUpdateManyMutationInput, TelemetryArtifactUncheckedUpdateManyInput>
    /**
     * Filter which TelemetryArtifacts to update
     */
    where?: TelemetryArtifactWhereInput
    /**
     * Limit how many TelemetryArtifacts to update.
     */
    limit?: number
  }

  /**
   * TelemetryArtifact upsert
   */
  export type TelemetryArtifactUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * The filter to search for the TelemetryArtifact to update in case it exists.
     */
    where: TelemetryArtifactWhereUniqueInput
    /**
     * In case the TelemetryArtifact found by the `where` argument doesn't exist, create a new TelemetryArtifact with this data.
     */
    create: XOR<TelemetryArtifactCreateInput, TelemetryArtifactUncheckedCreateInput>
    /**
     * In case the TelemetryArtifact was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TelemetryArtifactUpdateInput, TelemetryArtifactUncheckedUpdateInput>
  }

  /**
   * TelemetryArtifact delete
   */
  export type TelemetryArtifactDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryArtifact
     */
    select?: TelemetryArtifactSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryArtifact
     */
    omit?: TelemetryArtifactOmit<ExtArgs> | null
    /**
     * Filter which TelemetryArtifact to delete.
     */
    where: TelemetryArtifactWhereUniqueInput
  }

  /**
   * TelemetryArtifact deleteMany
   */
  export type TelemetryArtifactDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TelemetryArtifacts to delete
     */
    where?: TelemetryArtifactWhereInput
    /**
     * Limit how many TelemetryArtifacts to delete.
     */
    limit?: number
  }

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


  /**
   * Model TelemetryMetricPoint
   */

  export type AggregateTelemetryMetricPoint = {
    _count: TelemetryMetricPointCountAggregateOutputType | null
    _avg: TelemetryMetricPointAvgAggregateOutputType | null
    _sum: TelemetryMetricPointSumAggregateOutputType | null
    _min: TelemetryMetricPointMinAggregateOutputType | null
    _max: TelemetryMetricPointMaxAggregateOutputType | null
  }

  export type TelemetryMetricPointAvgAggregateOutputType = {
    value: number | null
    itemIndex: number | null
  }

  export type TelemetryMetricPointSumAggregateOutputType = {
    value: number | null
    itemIndex: number | null
  }

  export type TelemetryMetricPointMinAggregateOutputType = {
    metricPointId: string | null
    traceId: string | null
    spanId: string | null
    runId: string | null
    workflowId: string | null
    nodeId: string | null
    activationId: string | null
    metricName: string | null
    value: number | null
    unit: string | null
    observedAt: string | null
    workflowFolder: string | null
    nodeType: string | null
    nodeRole: string | null
    modelName: string | null
    dimensionsJson: string | null
    retentionExpiresAt: string | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
  }

  export type TelemetryMetricPointMaxAggregateOutputType = {
    metricPointId: string | null
    traceId: string | null
    spanId: string | null
    runId: string | null
    workflowId: string | null
    nodeId: string | null
    activationId: string | null
    metricName: string | null
    value: number | null
    unit: string | null
    observedAt: string | null
    workflowFolder: string | null
    nodeType: string | null
    nodeRole: string | null
    modelName: string | null
    dimensionsJson: string | null
    retentionExpiresAt: string | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
  }

  export type TelemetryMetricPointCountAggregateOutputType = {
    metricPointId: number
    traceId: number
    spanId: number
    runId: number
    workflowId: number
    nodeId: number
    activationId: number
    metricName: number
    value: number
    unit: number
    observedAt: number
    workflowFolder: number
    nodeType: number
    nodeRole: number
    modelName: number
    dimensionsJson: number
    retentionExpiresAt: number
    iterationId: number
    itemIndex: number
    parentInvocationId: number
    _all: number
  }


  export type TelemetryMetricPointAvgAggregateInputType = {
    value?: true
    itemIndex?: true
  }

  export type TelemetryMetricPointSumAggregateInputType = {
    value?: true
    itemIndex?: true
  }

  export type TelemetryMetricPointMinAggregateInputType = {
    metricPointId?: true
    traceId?: true
    spanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    metricName?: true
    value?: true
    unit?: true
    observedAt?: true
    workflowFolder?: true
    nodeType?: true
    nodeRole?: true
    modelName?: true
    dimensionsJson?: true
    retentionExpiresAt?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
  }

  export type TelemetryMetricPointMaxAggregateInputType = {
    metricPointId?: true
    traceId?: true
    spanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    metricName?: true
    value?: true
    unit?: true
    observedAt?: true
    workflowFolder?: true
    nodeType?: true
    nodeRole?: true
    modelName?: true
    dimensionsJson?: true
    retentionExpiresAt?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
  }

  export type TelemetryMetricPointCountAggregateInputType = {
    metricPointId?: true
    traceId?: true
    spanId?: true
    runId?: true
    workflowId?: true
    nodeId?: true
    activationId?: true
    metricName?: true
    value?: true
    unit?: true
    observedAt?: true
    workflowFolder?: true
    nodeType?: true
    nodeRole?: true
    modelName?: true
    dimensionsJson?: true
    retentionExpiresAt?: true
    iterationId?: true
    itemIndex?: true
    parentInvocationId?: true
    _all?: true
  }

  export type TelemetryMetricPointAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TelemetryMetricPoint to aggregate.
     */
    where?: TelemetryMetricPointWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TelemetryMetricPoints to fetch.
     */
    orderBy?: TelemetryMetricPointOrderByWithRelationInput | TelemetryMetricPointOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TelemetryMetricPointWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TelemetryMetricPoints 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` TelemetryMetricPoints.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TelemetryMetricPoints
    **/
    _count?: true | TelemetryMetricPointCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TelemetryMetricPointAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TelemetryMetricPointSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TelemetryMetricPointMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TelemetryMetricPointMaxAggregateInputType
  }

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




  export type TelemetryMetricPointGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TelemetryMetricPointWhereInput
    orderBy?: TelemetryMetricPointOrderByWithAggregationInput | TelemetryMetricPointOrderByWithAggregationInput[]
    by: TelemetryMetricPointScalarFieldEnum[] | TelemetryMetricPointScalarFieldEnum
    having?: TelemetryMetricPointScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TelemetryMetricPointCountAggregateInputType | true
    _avg?: TelemetryMetricPointAvgAggregateInputType
    _sum?: TelemetryMetricPointSumAggregateInputType
    _min?: TelemetryMetricPointMinAggregateInputType
    _max?: TelemetryMetricPointMaxAggregateInputType
  }

  export type TelemetryMetricPointGroupByOutputType = {
    metricPointId: string
    traceId: string | null
    spanId: string | null
    runId: string | null
    workflowId: string
    nodeId: string | null
    activationId: string | null
    metricName: string
    value: number
    unit: string | null
    observedAt: string
    workflowFolder: string | null
    nodeType: string | null
    nodeRole: string | null
    modelName: string | null
    dimensionsJson: string | null
    retentionExpiresAt: string | null
    iterationId: string | null
    itemIndex: number | null
    parentInvocationId: string | null
    _count: TelemetryMetricPointCountAggregateOutputType | null
    _avg: TelemetryMetricPointAvgAggregateOutputType | null
    _sum: TelemetryMetricPointSumAggregateOutputType | null
    _min: TelemetryMetricPointMinAggregateOutputType | null
    _max: TelemetryMetricPointMaxAggregateOutputType | null
  }

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


  export type TelemetryMetricPointSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    metricPointId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    metricName?: boolean
    value?: boolean
    unit?: boolean
    observedAt?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    dimensionsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
  }, ExtArgs["result"]["telemetryMetricPoint"]>

  export type TelemetryMetricPointSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    metricPointId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    metricName?: boolean
    value?: boolean
    unit?: boolean
    observedAt?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    dimensionsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
  }, ExtArgs["result"]["telemetryMetricPoint"]>

  export type TelemetryMetricPointSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    metricPointId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    metricName?: boolean
    value?: boolean
    unit?: boolean
    observedAt?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    dimensionsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
  }, ExtArgs["result"]["telemetryMetricPoint"]>

  export type TelemetryMetricPointSelectScalar = {
    metricPointId?: boolean
    traceId?: boolean
    spanId?: boolean
    runId?: boolean
    workflowId?: boolean
    nodeId?: boolean
    activationId?: boolean
    metricName?: boolean
    value?: boolean
    unit?: boolean
    observedAt?: boolean
    workflowFolder?: boolean
    nodeType?: boolean
    nodeRole?: boolean
    modelName?: boolean
    dimensionsJson?: boolean
    retentionExpiresAt?: boolean
    iterationId?: boolean
    itemIndex?: boolean
    parentInvocationId?: boolean
  }

  export type TelemetryMetricPointOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"metricPointId" | "traceId" | "spanId" | "runId" | "workflowId" | "nodeId" | "activationId" | "metricName" | "value" | "unit" | "observedAt" | "workflowFolder" | "nodeType" | "nodeRole" | "modelName" | "dimensionsJson" | "retentionExpiresAt" | "iterationId" | "itemIndex" | "parentInvocationId", ExtArgs["result"]["telemetryMetricPoint"]>

  export type $TelemetryMetricPointPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TelemetryMetricPoint"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      metricPointId: string
      traceId: string | null
      spanId: string | null
      runId: string | null
      workflowId: string
      nodeId: string | null
      activationId: string | null
      metricName: string
      value: number
      unit: string | null
      observedAt: string
      workflowFolder: string | null
      nodeType: string | null
      nodeRole: string | null
      modelName: string | null
      dimensionsJson: string | null
      retentionExpiresAt: string | null
      iterationId: string | null
      itemIndex: number | null
      parentInvocationId: string | null
    }, ExtArgs["result"]["telemetryMetricPoint"]>
    composites: {}
  }

  type TelemetryMetricPointGetPayload<S extends boolean | null | undefined | TelemetryMetricPointDefaultArgs> = $Result.GetResult<Prisma.$TelemetryMetricPointPayload, S>

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

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

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

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

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

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

    /**
     * Create a TelemetryMetricPoint.
     * @param {TelemetryMetricPointCreateArgs} args - Arguments to create a TelemetryMetricPoint.
     * @example
     * // Create one TelemetryMetricPoint
     * const TelemetryMetricPoint = await prisma.telemetryMetricPoint.create({
     *   data: {
     *     // ... data to create a TelemetryMetricPoint
     *   }
     * })
     * 
     */
    create<T extends TelemetryMetricPointCreateArgs>(args: SelectSubset<T, TelemetryMetricPointCreateArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many TelemetryMetricPoints and returns the data saved in the database.
     * @param {TelemetryMetricPointCreateManyAndReturnArgs} args - Arguments to create many TelemetryMetricPoints.
     * @example
     * // Create many TelemetryMetricPoints
     * const telemetryMetricPoint = await prisma.telemetryMetricPoint.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TelemetryMetricPoints and only return the `metricPointId`
     * const telemetryMetricPointWithMetricPointIdOnly = await prisma.telemetryMetricPoint.createManyAndReturn({
     *   select: { metricPointId: 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 TelemetryMetricPointCreateManyAndReturnArgs>(args?: SelectSubset<T, TelemetryMetricPointCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TelemetryMetricPoint.
     * @param {TelemetryMetricPointDeleteArgs} args - Arguments to delete one TelemetryMetricPoint.
     * @example
     * // Delete one TelemetryMetricPoint
     * const TelemetryMetricPoint = await prisma.telemetryMetricPoint.delete({
     *   where: {
     *     // ... filter to delete one TelemetryMetricPoint
     *   }
     * })
     * 
     */
    delete<T extends TelemetryMetricPointDeleteArgs>(args: SelectSubset<T, TelemetryMetricPointDeleteArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the TelemetryMetricPoint model
   */
  interface TelemetryMetricPointFieldRefs {
    readonly metricPointId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly traceId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly spanId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly runId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly workflowId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly nodeId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly activationId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly metricName: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly value: FieldRef<"TelemetryMetricPoint", 'Float'>
    readonly unit: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly observedAt: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly workflowFolder: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly nodeType: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly nodeRole: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly modelName: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly dimensionsJson: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly retentionExpiresAt: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly iterationId: FieldRef<"TelemetryMetricPoint", 'String'>
    readonly itemIndex: FieldRef<"TelemetryMetricPoint", 'Int'>
    readonly parentInvocationId: FieldRef<"TelemetryMetricPoint", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TelemetryMetricPoint findUnique
   */
  export type TelemetryMetricPointFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * Filter, which TelemetryMetricPoint to fetch.
     */
    where: TelemetryMetricPointWhereUniqueInput
  }

  /**
   * TelemetryMetricPoint findUniqueOrThrow
   */
  export type TelemetryMetricPointFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * Filter, which TelemetryMetricPoint to fetch.
     */
    where: TelemetryMetricPointWhereUniqueInput
  }

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

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

  /**
   * TelemetryMetricPoint findMany
   */
  export type TelemetryMetricPointFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * Filter, which TelemetryMetricPoints to fetch.
     */
    where?: TelemetryMetricPointWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TelemetryMetricPoints to fetch.
     */
    orderBy?: TelemetryMetricPointOrderByWithRelationInput | TelemetryMetricPointOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TelemetryMetricPoints.
     */
    cursor?: TelemetryMetricPointWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TelemetryMetricPoints 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` TelemetryMetricPoints.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TelemetryMetricPoints.
     */
    distinct?: TelemetryMetricPointScalarFieldEnum | TelemetryMetricPointScalarFieldEnum[]
  }

  /**
   * TelemetryMetricPoint create
   */
  export type TelemetryMetricPointCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * The data needed to create a TelemetryMetricPoint.
     */
    data: XOR<TelemetryMetricPointCreateInput, TelemetryMetricPointUncheckedCreateInput>
  }

  /**
   * TelemetryMetricPoint createMany
   */
  export type TelemetryMetricPointCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TelemetryMetricPoints.
     */
    data: TelemetryMetricPointCreateManyInput | TelemetryMetricPointCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TelemetryMetricPoint createManyAndReturn
   */
  export type TelemetryMetricPointCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * The data used to create many TelemetryMetricPoints.
     */
    data: TelemetryMetricPointCreateManyInput | TelemetryMetricPointCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TelemetryMetricPoint update
   */
  export type TelemetryMetricPointUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * The data needed to update a TelemetryMetricPoint.
     */
    data: XOR<TelemetryMetricPointUpdateInput, TelemetryMetricPointUncheckedUpdateInput>
    /**
     * Choose, which TelemetryMetricPoint to update.
     */
    where: TelemetryMetricPointWhereUniqueInput
  }

  /**
   * TelemetryMetricPoint updateMany
   */
  export type TelemetryMetricPointUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TelemetryMetricPoints.
     */
    data: XOR<TelemetryMetricPointUpdateManyMutationInput, TelemetryMetricPointUncheckedUpdateManyInput>
    /**
     * Filter which TelemetryMetricPoints to update
     */
    where?: TelemetryMetricPointWhereInput
    /**
     * Limit how many TelemetryMetricPoints to update.
     */
    limit?: number
  }

  /**
   * TelemetryMetricPoint updateManyAndReturn
   */
  export type TelemetryMetricPointUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * The data used to update TelemetryMetricPoints.
     */
    data: XOR<TelemetryMetricPointUpdateManyMutationInput, TelemetryMetricPointUncheckedUpdateManyInput>
    /**
     * Filter which TelemetryMetricPoints to update
     */
    where?: TelemetryMetricPointWhereInput
    /**
     * Limit how many TelemetryMetricPoints to update.
     */
    limit?: number
  }

  /**
   * TelemetryMetricPoint upsert
   */
  export type TelemetryMetricPointUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * The filter to search for the TelemetryMetricPoint to update in case it exists.
     */
    where: TelemetryMetricPointWhereUniqueInput
    /**
     * In case the TelemetryMetricPoint found by the `where` argument doesn't exist, create a new TelemetryMetricPoint with this data.
     */
    create: XOR<TelemetryMetricPointCreateInput, TelemetryMetricPointUncheckedCreateInput>
    /**
     * In case the TelemetryMetricPoint was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TelemetryMetricPointUpdateInput, TelemetryMetricPointUncheckedUpdateInput>
  }

  /**
   * TelemetryMetricPoint delete
   */
  export type TelemetryMetricPointDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TelemetryMetricPoint
     */
    select?: TelemetryMetricPointSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TelemetryMetricPoint
     */
    omit?: TelemetryMetricPointOmit<ExtArgs> | null
    /**
     * Filter which TelemetryMetricPoint to delete.
     */
    where: TelemetryMetricPointWhereUniqueInput
  }

  /**
   * TelemetryMetricPoint deleteMany
   */
  export type TelemetryMetricPointDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TelemetryMetricPoints to delete
     */
    where?: TelemetryMetricPointWhereInput
    /**
     * Limit how many TelemetryMetricPoints to delete.
     */
    limit?: number
  }

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


  /**
   * Model CredentialInstance
   */

  export type AggregateCredentialInstance = {
    _count: CredentialInstanceCountAggregateOutputType | null
    _min: CredentialInstanceMinAggregateOutputType | null
    _max: CredentialInstanceMaxAggregateOutputType | null
  }

  export type CredentialInstanceMinAggregateOutputType = {
    instanceId: string | null
    typeId: string | null
    displayName: string | null
    sourceKind: string | null
    publicConfigJson: string | null
    secretRefJson: string | null
    tagsJson: string | null
    setupStatus: string | null
    createdAt: string | null
    updatedAt: string | null
    materialSource: string | null
    materialRef: string | null
  }

  export type CredentialInstanceMaxAggregateOutputType = {
    instanceId: string | null
    typeId: string | null
    displayName: string | null
    sourceKind: string | null
    publicConfigJson: string | null
    secretRefJson: string | null
    tagsJson: string | null
    setupStatus: string | null
    createdAt: string | null
    updatedAt: string | null
    materialSource: string | null
    materialRef: string | null
  }

  export type CredentialInstanceCountAggregateOutputType = {
    instanceId: number
    typeId: number
    displayName: number
    sourceKind: number
    publicConfigJson: number
    secretRefJson: number
    tagsJson: number
    setupStatus: number
    createdAt: number
    updatedAt: number
    materialSource: number
    materialRef: number
    _all: number
  }


  export type CredentialInstanceMinAggregateInputType = {
    instanceId?: true
    typeId?: true
    displayName?: true
    sourceKind?: true
    publicConfigJson?: true
    secretRefJson?: true
    tagsJson?: true
    setupStatus?: true
    createdAt?: true
    updatedAt?: true
    materialSource?: true
    materialRef?: true
  }

  export type CredentialInstanceMaxAggregateInputType = {
    instanceId?: true
    typeId?: true
    displayName?: true
    sourceKind?: true
    publicConfigJson?: true
    secretRefJson?: true
    tagsJson?: true
    setupStatus?: true
    createdAt?: true
    updatedAt?: true
    materialSource?: true
    materialRef?: true
  }

  export type CredentialInstanceCountAggregateInputType = {
    instanceId?: true
    typeId?: true
    displayName?: true
    sourceKind?: true
    publicConfigJson?: true
    secretRefJson?: true
    tagsJson?: true
    setupStatus?: true
    createdAt?: true
    updatedAt?: true
    materialSource?: true
    materialRef?: true
    _all?: true
  }

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

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




  export type CredentialInstanceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CredentialInstanceWhereInput
    orderBy?: CredentialInstanceOrderByWithAggregationInput | CredentialInstanceOrderByWithAggregationInput[]
    by: CredentialInstanceScalarFieldEnum[] | CredentialInstanceScalarFieldEnum
    having?: CredentialInstanceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CredentialInstanceCountAggregateInputType | true
    _min?: CredentialInstanceMinAggregateInputType
    _max?: CredentialInstanceMaxAggregateInputType
  }

  export type CredentialInstanceGroupByOutputType = {
    instanceId: string
    typeId: string
    displayName: string
    sourceKind: string
    publicConfigJson: string
    secretRefJson: string
    tagsJson: string
    setupStatus: string
    createdAt: string
    updatedAt: string
    materialSource: string
    materialRef: string
    _count: CredentialInstanceCountAggregateOutputType | null
    _min: CredentialInstanceMinAggregateOutputType | null
    _max: CredentialInstanceMaxAggregateOutputType | null
  }

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


  export type CredentialInstanceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    typeId?: boolean
    displayName?: boolean
    sourceKind?: boolean
    publicConfigJson?: boolean
    secretRefJson?: boolean
    tagsJson?: boolean
    setupStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    materialSource?: boolean
    materialRef?: boolean
  }, ExtArgs["result"]["credentialInstance"]>

  export type CredentialInstanceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    typeId?: boolean
    displayName?: boolean
    sourceKind?: boolean
    publicConfigJson?: boolean
    secretRefJson?: boolean
    tagsJson?: boolean
    setupStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    materialSource?: boolean
    materialRef?: boolean
  }, ExtArgs["result"]["credentialInstance"]>

  export type CredentialInstanceSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    typeId?: boolean
    displayName?: boolean
    sourceKind?: boolean
    publicConfigJson?: boolean
    secretRefJson?: boolean
    tagsJson?: boolean
    setupStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    materialSource?: boolean
    materialRef?: boolean
  }, ExtArgs["result"]["credentialInstance"]>

  export type CredentialInstanceSelectScalar = {
    instanceId?: boolean
    typeId?: boolean
    displayName?: boolean
    sourceKind?: boolean
    publicConfigJson?: boolean
    secretRefJson?: boolean
    tagsJson?: boolean
    setupStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    materialSource?: boolean
    materialRef?: boolean
  }

  export type CredentialInstanceOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"instanceId" | "typeId" | "displayName" | "sourceKind" | "publicConfigJson" | "secretRefJson" | "tagsJson" | "setupStatus" | "createdAt" | "updatedAt" | "materialSource" | "materialRef", ExtArgs["result"]["credentialInstance"]>

  export type $CredentialInstancePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CredentialInstance"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      instanceId: string
      typeId: string
      displayName: string
      sourceKind: string
      publicConfigJson: string
      secretRefJson: string
      tagsJson: string
      setupStatus: string
      createdAt: string
      updatedAt: string
      materialSource: string
      materialRef: string
    }, ExtArgs["result"]["credentialInstance"]>
    composites: {}
  }

  type CredentialInstanceGetPayload<S extends boolean | null | undefined | CredentialInstanceDefaultArgs> = $Result.GetResult<Prisma.$CredentialInstancePayload, S>

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

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

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

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

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

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

    /**
     * Create a CredentialInstance.
     * @param {CredentialInstanceCreateArgs} args - Arguments to create a CredentialInstance.
     * @example
     * // Create one CredentialInstance
     * const CredentialInstance = await prisma.credentialInstance.create({
     *   data: {
     *     // ... data to create a CredentialInstance
     *   }
     * })
     * 
     */
    create<T extends CredentialInstanceCreateArgs>(args: SelectSubset<T, CredentialInstanceCreateArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CredentialInstances and returns the data saved in the database.
     * @param {CredentialInstanceCreateManyAndReturnArgs} args - Arguments to create many CredentialInstances.
     * @example
     * // Create many CredentialInstances
     * const credentialInstance = await prisma.credentialInstance.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CredentialInstances and only return the `instanceId`
     * const credentialInstanceWithInstanceIdOnly = await prisma.credentialInstance.createManyAndReturn({
     *   select: { instanceId: 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 CredentialInstanceCreateManyAndReturnArgs>(args?: SelectSubset<T, CredentialInstanceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CredentialInstance.
     * @param {CredentialInstanceDeleteArgs} args - Arguments to delete one CredentialInstance.
     * @example
     * // Delete one CredentialInstance
     * const CredentialInstance = await prisma.credentialInstance.delete({
     *   where: {
     *     // ... filter to delete one CredentialInstance
     *   }
     * })
     * 
     */
    delete<T extends CredentialInstanceDeleteArgs>(args: SelectSubset<T, CredentialInstanceDeleteArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the CredentialInstance model
   */
  interface CredentialInstanceFieldRefs {
    readonly instanceId: FieldRef<"CredentialInstance", 'String'>
    readonly typeId: FieldRef<"CredentialInstance", 'String'>
    readonly displayName: FieldRef<"CredentialInstance", 'String'>
    readonly sourceKind: FieldRef<"CredentialInstance", 'String'>
    readonly publicConfigJson: FieldRef<"CredentialInstance", 'String'>
    readonly secretRefJson: FieldRef<"CredentialInstance", 'String'>
    readonly tagsJson: FieldRef<"CredentialInstance", 'String'>
    readonly setupStatus: FieldRef<"CredentialInstance", 'String'>
    readonly createdAt: FieldRef<"CredentialInstance", 'String'>
    readonly updatedAt: FieldRef<"CredentialInstance", 'String'>
    readonly materialSource: FieldRef<"CredentialInstance", 'String'>
    readonly materialRef: FieldRef<"CredentialInstance", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CredentialInstance findUnique
   */
  export type CredentialInstanceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * Filter, which CredentialInstance to fetch.
     */
    where: CredentialInstanceWhereUniqueInput
  }

  /**
   * CredentialInstance findUniqueOrThrow
   */
  export type CredentialInstanceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * Filter, which CredentialInstance to fetch.
     */
    where: CredentialInstanceWhereUniqueInput
  }

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

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

  /**
   * CredentialInstance findMany
   */
  export type CredentialInstanceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * Filter, which CredentialInstances to fetch.
     */
    where?: CredentialInstanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialInstances to fetch.
     */
    orderBy?: CredentialInstanceOrderByWithRelationInput | CredentialInstanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CredentialInstances.
     */
    cursor?: CredentialInstanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialInstances 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` CredentialInstances.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CredentialInstances.
     */
    distinct?: CredentialInstanceScalarFieldEnum | CredentialInstanceScalarFieldEnum[]
  }

  /**
   * CredentialInstance create
   */
  export type CredentialInstanceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * The data needed to create a CredentialInstance.
     */
    data: XOR<CredentialInstanceCreateInput, CredentialInstanceUncheckedCreateInput>
  }

  /**
   * CredentialInstance createMany
   */
  export type CredentialInstanceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CredentialInstances.
     */
    data: CredentialInstanceCreateManyInput | CredentialInstanceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialInstance createManyAndReturn
   */
  export type CredentialInstanceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * The data used to create many CredentialInstances.
     */
    data: CredentialInstanceCreateManyInput | CredentialInstanceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialInstance update
   */
  export type CredentialInstanceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * The data needed to update a CredentialInstance.
     */
    data: XOR<CredentialInstanceUpdateInput, CredentialInstanceUncheckedUpdateInput>
    /**
     * Choose, which CredentialInstance to update.
     */
    where: CredentialInstanceWhereUniqueInput
  }

  /**
   * CredentialInstance updateMany
   */
  export type CredentialInstanceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CredentialInstances.
     */
    data: XOR<CredentialInstanceUpdateManyMutationInput, CredentialInstanceUncheckedUpdateManyInput>
    /**
     * Filter which CredentialInstances to update
     */
    where?: CredentialInstanceWhereInput
    /**
     * Limit how many CredentialInstances to update.
     */
    limit?: number
  }

  /**
   * CredentialInstance updateManyAndReturn
   */
  export type CredentialInstanceUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * The data used to update CredentialInstances.
     */
    data: XOR<CredentialInstanceUpdateManyMutationInput, CredentialInstanceUncheckedUpdateManyInput>
    /**
     * Filter which CredentialInstances to update
     */
    where?: CredentialInstanceWhereInput
    /**
     * Limit how many CredentialInstances to update.
     */
    limit?: number
  }

  /**
   * CredentialInstance upsert
   */
  export type CredentialInstanceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * The filter to search for the CredentialInstance to update in case it exists.
     */
    where: CredentialInstanceWhereUniqueInput
    /**
     * In case the CredentialInstance found by the `where` argument doesn't exist, create a new CredentialInstance with this data.
     */
    create: XOR<CredentialInstanceCreateInput, CredentialInstanceUncheckedCreateInput>
    /**
     * In case the CredentialInstance was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CredentialInstanceUpdateInput, CredentialInstanceUncheckedUpdateInput>
  }

  /**
   * CredentialInstance delete
   */
  export type CredentialInstanceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialInstance
     */
    select?: CredentialInstanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialInstance
     */
    omit?: CredentialInstanceOmit<ExtArgs> | null
    /**
     * Filter which CredentialInstance to delete.
     */
    where: CredentialInstanceWhereUniqueInput
  }

  /**
   * CredentialInstance deleteMany
   */
  export type CredentialInstanceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialInstances to delete
     */
    where?: CredentialInstanceWhereInput
    /**
     * Limit how many CredentialInstances to delete.
     */
    limit?: number
  }

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


  /**
   * Model CredentialSecretMaterial
   */

  export type AggregateCredentialSecretMaterial = {
    _count: CredentialSecretMaterialCountAggregateOutputType | null
    _avg: CredentialSecretMaterialAvgAggregateOutputType | null
    _sum: CredentialSecretMaterialSumAggregateOutputType | null
    _min: CredentialSecretMaterialMinAggregateOutputType | null
    _max: CredentialSecretMaterialMaxAggregateOutputType | null
  }

  export type CredentialSecretMaterialAvgAggregateOutputType = {
    schemaVersion: number | null
  }

  export type CredentialSecretMaterialSumAggregateOutputType = {
    schemaVersion: number | null
  }

  export type CredentialSecretMaterialMinAggregateOutputType = {
    instanceId: string | null
    encryptedJson: string | null
    encryptionKeyId: string | null
    schemaVersion: number | null
    updatedAt: string | null
  }

  export type CredentialSecretMaterialMaxAggregateOutputType = {
    instanceId: string | null
    encryptedJson: string | null
    encryptionKeyId: string | null
    schemaVersion: number | null
    updatedAt: string | null
  }

  export type CredentialSecretMaterialCountAggregateOutputType = {
    instanceId: number
    encryptedJson: number
    encryptionKeyId: number
    schemaVersion: number
    updatedAt: number
    _all: number
  }


  export type CredentialSecretMaterialAvgAggregateInputType = {
    schemaVersion?: true
  }

  export type CredentialSecretMaterialSumAggregateInputType = {
    schemaVersion?: true
  }

  export type CredentialSecretMaterialMinAggregateInputType = {
    instanceId?: true
    encryptedJson?: true
    encryptionKeyId?: true
    schemaVersion?: true
    updatedAt?: true
  }

  export type CredentialSecretMaterialMaxAggregateInputType = {
    instanceId?: true
    encryptedJson?: true
    encryptionKeyId?: true
    schemaVersion?: true
    updatedAt?: true
  }

  export type CredentialSecretMaterialCountAggregateInputType = {
    instanceId?: true
    encryptedJson?: true
    encryptionKeyId?: true
    schemaVersion?: true
    updatedAt?: true
    _all?: true
  }

  export type CredentialSecretMaterialAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialSecretMaterial to aggregate.
     */
    where?: CredentialSecretMaterialWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialSecretMaterials to fetch.
     */
    orderBy?: CredentialSecretMaterialOrderByWithRelationInput | CredentialSecretMaterialOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CredentialSecretMaterialWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialSecretMaterials 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` CredentialSecretMaterials.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CredentialSecretMaterials
    **/
    _count?: true | CredentialSecretMaterialCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CredentialSecretMaterialAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CredentialSecretMaterialSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CredentialSecretMaterialMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CredentialSecretMaterialMaxAggregateInputType
  }

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




  export type CredentialSecretMaterialGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CredentialSecretMaterialWhereInput
    orderBy?: CredentialSecretMaterialOrderByWithAggregationInput | CredentialSecretMaterialOrderByWithAggregationInput[]
    by: CredentialSecretMaterialScalarFieldEnum[] | CredentialSecretMaterialScalarFieldEnum
    having?: CredentialSecretMaterialScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CredentialSecretMaterialCountAggregateInputType | true
    _avg?: CredentialSecretMaterialAvgAggregateInputType
    _sum?: CredentialSecretMaterialSumAggregateInputType
    _min?: CredentialSecretMaterialMinAggregateInputType
    _max?: CredentialSecretMaterialMaxAggregateInputType
  }

  export type CredentialSecretMaterialGroupByOutputType = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    updatedAt: string
    _count: CredentialSecretMaterialCountAggregateOutputType | null
    _avg: CredentialSecretMaterialAvgAggregateOutputType | null
    _sum: CredentialSecretMaterialSumAggregateOutputType | null
    _min: CredentialSecretMaterialMinAggregateOutputType | null
    _max: CredentialSecretMaterialMaxAggregateOutputType | null
  }

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


  export type CredentialSecretMaterialSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialSecretMaterial"]>

  export type CredentialSecretMaterialSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialSecretMaterial"]>

  export type CredentialSecretMaterialSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialSecretMaterial"]>

  export type CredentialSecretMaterialSelectScalar = {
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    updatedAt?: boolean
  }

  export type CredentialSecretMaterialOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"instanceId" | "encryptedJson" | "encryptionKeyId" | "schemaVersion" | "updatedAt", ExtArgs["result"]["credentialSecretMaterial"]>

  export type $CredentialSecretMaterialPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CredentialSecretMaterial"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      instanceId: string
      encryptedJson: string
      encryptionKeyId: string
      schemaVersion: number
      updatedAt: string
    }, ExtArgs["result"]["credentialSecretMaterial"]>
    composites: {}
  }

  type CredentialSecretMaterialGetPayload<S extends boolean | null | undefined | CredentialSecretMaterialDefaultArgs> = $Result.GetResult<Prisma.$CredentialSecretMaterialPayload, S>

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

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

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

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

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

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

    /**
     * Create a CredentialSecretMaterial.
     * @param {CredentialSecretMaterialCreateArgs} args - Arguments to create a CredentialSecretMaterial.
     * @example
     * // Create one CredentialSecretMaterial
     * const CredentialSecretMaterial = await prisma.credentialSecretMaterial.create({
     *   data: {
     *     // ... data to create a CredentialSecretMaterial
     *   }
     * })
     * 
     */
    create<T extends CredentialSecretMaterialCreateArgs>(args: SelectSubset<T, CredentialSecretMaterialCreateArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CredentialSecretMaterials and returns the data saved in the database.
     * @param {CredentialSecretMaterialCreateManyAndReturnArgs} args - Arguments to create many CredentialSecretMaterials.
     * @example
     * // Create many CredentialSecretMaterials
     * const credentialSecretMaterial = await prisma.credentialSecretMaterial.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CredentialSecretMaterials and only return the `instanceId`
     * const credentialSecretMaterialWithInstanceIdOnly = await prisma.credentialSecretMaterial.createManyAndReturn({
     *   select: { instanceId: 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 CredentialSecretMaterialCreateManyAndReturnArgs>(args?: SelectSubset<T, CredentialSecretMaterialCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CredentialSecretMaterial.
     * @param {CredentialSecretMaterialDeleteArgs} args - Arguments to delete one CredentialSecretMaterial.
     * @example
     * // Delete one CredentialSecretMaterial
     * const CredentialSecretMaterial = await prisma.credentialSecretMaterial.delete({
     *   where: {
     *     // ... filter to delete one CredentialSecretMaterial
     *   }
     * })
     * 
     */
    delete<T extends CredentialSecretMaterialDeleteArgs>(args: SelectSubset<T, CredentialSecretMaterialDeleteArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the CredentialSecretMaterial model
   */
  interface CredentialSecretMaterialFieldRefs {
    readonly instanceId: FieldRef<"CredentialSecretMaterial", 'String'>
    readonly encryptedJson: FieldRef<"CredentialSecretMaterial", 'String'>
    readonly encryptionKeyId: FieldRef<"CredentialSecretMaterial", 'String'>
    readonly schemaVersion: FieldRef<"CredentialSecretMaterial", 'Int'>
    readonly updatedAt: FieldRef<"CredentialSecretMaterial", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CredentialSecretMaterial findUnique
   */
  export type CredentialSecretMaterialFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * Filter, which CredentialSecretMaterial to fetch.
     */
    where: CredentialSecretMaterialWhereUniqueInput
  }

  /**
   * CredentialSecretMaterial findUniqueOrThrow
   */
  export type CredentialSecretMaterialFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * Filter, which CredentialSecretMaterial to fetch.
     */
    where: CredentialSecretMaterialWhereUniqueInput
  }

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

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

  /**
   * CredentialSecretMaterial findMany
   */
  export type CredentialSecretMaterialFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * Filter, which CredentialSecretMaterials to fetch.
     */
    where?: CredentialSecretMaterialWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialSecretMaterials to fetch.
     */
    orderBy?: CredentialSecretMaterialOrderByWithRelationInput | CredentialSecretMaterialOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CredentialSecretMaterials.
     */
    cursor?: CredentialSecretMaterialWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialSecretMaterials 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` CredentialSecretMaterials.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CredentialSecretMaterials.
     */
    distinct?: CredentialSecretMaterialScalarFieldEnum | CredentialSecretMaterialScalarFieldEnum[]
  }

  /**
   * CredentialSecretMaterial create
   */
  export type CredentialSecretMaterialCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * The data needed to create a CredentialSecretMaterial.
     */
    data: XOR<CredentialSecretMaterialCreateInput, CredentialSecretMaterialUncheckedCreateInput>
  }

  /**
   * CredentialSecretMaterial createMany
   */
  export type CredentialSecretMaterialCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CredentialSecretMaterials.
     */
    data: CredentialSecretMaterialCreateManyInput | CredentialSecretMaterialCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialSecretMaterial createManyAndReturn
   */
  export type CredentialSecretMaterialCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * The data used to create many CredentialSecretMaterials.
     */
    data: CredentialSecretMaterialCreateManyInput | CredentialSecretMaterialCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialSecretMaterial update
   */
  export type CredentialSecretMaterialUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * The data needed to update a CredentialSecretMaterial.
     */
    data: XOR<CredentialSecretMaterialUpdateInput, CredentialSecretMaterialUncheckedUpdateInput>
    /**
     * Choose, which CredentialSecretMaterial to update.
     */
    where: CredentialSecretMaterialWhereUniqueInput
  }

  /**
   * CredentialSecretMaterial updateMany
   */
  export type CredentialSecretMaterialUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CredentialSecretMaterials.
     */
    data: XOR<CredentialSecretMaterialUpdateManyMutationInput, CredentialSecretMaterialUncheckedUpdateManyInput>
    /**
     * Filter which CredentialSecretMaterials to update
     */
    where?: CredentialSecretMaterialWhereInput
    /**
     * Limit how many CredentialSecretMaterials to update.
     */
    limit?: number
  }

  /**
   * CredentialSecretMaterial updateManyAndReturn
   */
  export type CredentialSecretMaterialUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * The data used to update CredentialSecretMaterials.
     */
    data: XOR<CredentialSecretMaterialUpdateManyMutationInput, CredentialSecretMaterialUncheckedUpdateManyInput>
    /**
     * Filter which CredentialSecretMaterials to update
     */
    where?: CredentialSecretMaterialWhereInput
    /**
     * Limit how many CredentialSecretMaterials to update.
     */
    limit?: number
  }

  /**
   * CredentialSecretMaterial upsert
   */
  export type CredentialSecretMaterialUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * The filter to search for the CredentialSecretMaterial to update in case it exists.
     */
    where: CredentialSecretMaterialWhereUniqueInput
    /**
     * In case the CredentialSecretMaterial found by the `where` argument doesn't exist, create a new CredentialSecretMaterial with this data.
     */
    create: XOR<CredentialSecretMaterialCreateInput, CredentialSecretMaterialUncheckedCreateInput>
    /**
     * In case the CredentialSecretMaterial was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CredentialSecretMaterialUpdateInput, CredentialSecretMaterialUncheckedUpdateInput>
  }

  /**
   * CredentialSecretMaterial delete
   */
  export type CredentialSecretMaterialDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialSecretMaterial
     */
    select?: CredentialSecretMaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialSecretMaterial
     */
    omit?: CredentialSecretMaterialOmit<ExtArgs> | null
    /**
     * Filter which CredentialSecretMaterial to delete.
     */
    where: CredentialSecretMaterialWhereUniqueInput
  }

  /**
   * CredentialSecretMaterial deleteMany
   */
  export type CredentialSecretMaterialDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialSecretMaterials to delete
     */
    where?: CredentialSecretMaterialWhereInput
    /**
     * Limit how many CredentialSecretMaterials to delete.
     */
    limit?: number
  }

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


  /**
   * Model CredentialOAuth2Material
   */

  export type AggregateCredentialOAuth2Material = {
    _count: CredentialOAuth2MaterialCountAggregateOutputType | null
    _avg: CredentialOAuth2MaterialAvgAggregateOutputType | null
    _sum: CredentialOAuth2MaterialSumAggregateOutputType | null
    _min: CredentialOAuth2MaterialMinAggregateOutputType | null
    _max: CredentialOAuth2MaterialMaxAggregateOutputType | null
  }

  export type CredentialOAuth2MaterialAvgAggregateOutputType = {
    schemaVersion: number | null
  }

  export type CredentialOAuth2MaterialSumAggregateOutputType = {
    schemaVersion: number | null
  }

  export type CredentialOAuth2MaterialMinAggregateOutputType = {
    instanceId: string | null
    encryptedJson: string | null
    encryptionKeyId: string | null
    schemaVersion: number | null
    providerId: string | null
    connectedEmail: string | null
    connectedAt: string | null
    scopesJson: string | null
    updatedAt: string | null
  }

  export type CredentialOAuth2MaterialMaxAggregateOutputType = {
    instanceId: string | null
    encryptedJson: string | null
    encryptionKeyId: string | null
    schemaVersion: number | null
    providerId: string | null
    connectedEmail: string | null
    connectedAt: string | null
    scopesJson: string | null
    updatedAt: string | null
  }

  export type CredentialOAuth2MaterialCountAggregateOutputType = {
    instanceId: number
    encryptedJson: number
    encryptionKeyId: number
    schemaVersion: number
    providerId: number
    connectedEmail: number
    connectedAt: number
    scopesJson: number
    updatedAt: number
    _all: number
  }


  export type CredentialOAuth2MaterialAvgAggregateInputType = {
    schemaVersion?: true
  }

  export type CredentialOAuth2MaterialSumAggregateInputType = {
    schemaVersion?: true
  }

  export type CredentialOAuth2MaterialMinAggregateInputType = {
    instanceId?: true
    encryptedJson?: true
    encryptionKeyId?: true
    schemaVersion?: true
    providerId?: true
    connectedEmail?: true
    connectedAt?: true
    scopesJson?: true
    updatedAt?: true
  }

  export type CredentialOAuth2MaterialMaxAggregateInputType = {
    instanceId?: true
    encryptedJson?: true
    encryptionKeyId?: true
    schemaVersion?: true
    providerId?: true
    connectedEmail?: true
    connectedAt?: true
    scopesJson?: true
    updatedAt?: true
  }

  export type CredentialOAuth2MaterialCountAggregateInputType = {
    instanceId?: true
    encryptedJson?: true
    encryptionKeyId?: true
    schemaVersion?: true
    providerId?: true
    connectedEmail?: true
    connectedAt?: true
    scopesJson?: true
    updatedAt?: true
    _all?: true
  }

  export type CredentialOAuth2MaterialAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialOAuth2Material to aggregate.
     */
    where?: CredentialOAuth2MaterialWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialOAuth2Materials to fetch.
     */
    orderBy?: CredentialOAuth2MaterialOrderByWithRelationInput | CredentialOAuth2MaterialOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CredentialOAuth2MaterialWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialOAuth2Materials 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` CredentialOAuth2Materials.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CredentialOAuth2Materials
    **/
    _count?: true | CredentialOAuth2MaterialCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CredentialOAuth2MaterialAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CredentialOAuth2MaterialSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CredentialOAuth2MaterialMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CredentialOAuth2MaterialMaxAggregateInputType
  }

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




  export type CredentialOAuth2MaterialGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CredentialOAuth2MaterialWhereInput
    orderBy?: CredentialOAuth2MaterialOrderByWithAggregationInput | CredentialOAuth2MaterialOrderByWithAggregationInput[]
    by: CredentialOAuth2MaterialScalarFieldEnum[] | CredentialOAuth2MaterialScalarFieldEnum
    having?: CredentialOAuth2MaterialScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CredentialOAuth2MaterialCountAggregateInputType | true
    _avg?: CredentialOAuth2MaterialAvgAggregateInputType
    _sum?: CredentialOAuth2MaterialSumAggregateInputType
    _min?: CredentialOAuth2MaterialMinAggregateInputType
    _max?: CredentialOAuth2MaterialMaxAggregateInputType
  }

  export type CredentialOAuth2MaterialGroupByOutputType = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    providerId: string
    connectedEmail: string | null
    connectedAt: string | null
    scopesJson: string
    updatedAt: string
    _count: CredentialOAuth2MaterialCountAggregateOutputType | null
    _avg: CredentialOAuth2MaterialAvgAggregateOutputType | null
    _sum: CredentialOAuth2MaterialSumAggregateOutputType | null
    _min: CredentialOAuth2MaterialMinAggregateOutputType | null
    _max: CredentialOAuth2MaterialMaxAggregateOutputType | null
  }

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


  export type CredentialOAuth2MaterialSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    providerId?: boolean
    connectedEmail?: boolean
    connectedAt?: boolean
    scopesJson?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialOAuth2Material"]>

  export type CredentialOAuth2MaterialSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    providerId?: boolean
    connectedEmail?: boolean
    connectedAt?: boolean
    scopesJson?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialOAuth2Material"]>

  export type CredentialOAuth2MaterialSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    providerId?: boolean
    connectedEmail?: boolean
    connectedAt?: boolean
    scopesJson?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialOAuth2Material"]>

  export type CredentialOAuth2MaterialSelectScalar = {
    instanceId?: boolean
    encryptedJson?: boolean
    encryptionKeyId?: boolean
    schemaVersion?: boolean
    providerId?: boolean
    connectedEmail?: boolean
    connectedAt?: boolean
    scopesJson?: boolean
    updatedAt?: boolean
  }

  export type CredentialOAuth2MaterialOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"instanceId" | "encryptedJson" | "encryptionKeyId" | "schemaVersion" | "providerId" | "connectedEmail" | "connectedAt" | "scopesJson" | "updatedAt", ExtArgs["result"]["credentialOAuth2Material"]>

  export type $CredentialOAuth2MaterialPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CredentialOAuth2Material"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      instanceId: string
      encryptedJson: string
      encryptionKeyId: string
      schemaVersion: number
      providerId: string
      connectedEmail: string | null
      connectedAt: string | null
      scopesJson: string
      updatedAt: string
    }, ExtArgs["result"]["credentialOAuth2Material"]>
    composites: {}
  }

  type CredentialOAuth2MaterialGetPayload<S extends boolean | null | undefined | CredentialOAuth2MaterialDefaultArgs> = $Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload, S>

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

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

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

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

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

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

    /**
     * Create a CredentialOAuth2Material.
     * @param {CredentialOAuth2MaterialCreateArgs} args - Arguments to create a CredentialOAuth2Material.
     * @example
     * // Create one CredentialOAuth2Material
     * const CredentialOAuth2Material = await prisma.credentialOAuth2Material.create({
     *   data: {
     *     // ... data to create a CredentialOAuth2Material
     *   }
     * })
     * 
     */
    create<T extends CredentialOAuth2MaterialCreateArgs>(args: SelectSubset<T, CredentialOAuth2MaterialCreateArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CredentialOAuth2Materials and returns the data saved in the database.
     * @param {CredentialOAuth2MaterialCreateManyAndReturnArgs} args - Arguments to create many CredentialOAuth2Materials.
     * @example
     * // Create many CredentialOAuth2Materials
     * const credentialOAuth2Material = await prisma.credentialOAuth2Material.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CredentialOAuth2Materials and only return the `instanceId`
     * const credentialOAuth2MaterialWithInstanceIdOnly = await prisma.credentialOAuth2Material.createManyAndReturn({
     *   select: { instanceId: 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 CredentialOAuth2MaterialCreateManyAndReturnArgs>(args?: SelectSubset<T, CredentialOAuth2MaterialCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CredentialOAuth2Material.
     * @param {CredentialOAuth2MaterialDeleteArgs} args - Arguments to delete one CredentialOAuth2Material.
     * @example
     * // Delete one CredentialOAuth2Material
     * const CredentialOAuth2Material = await prisma.credentialOAuth2Material.delete({
     *   where: {
     *     // ... filter to delete one CredentialOAuth2Material
     *   }
     * })
     * 
     */
    delete<T extends CredentialOAuth2MaterialDeleteArgs>(args: SelectSubset<T, CredentialOAuth2MaterialDeleteArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the CredentialOAuth2Material model
   */
  interface CredentialOAuth2MaterialFieldRefs {
    readonly instanceId: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly encryptedJson: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly encryptionKeyId: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly schemaVersion: FieldRef<"CredentialOAuth2Material", 'Int'>
    readonly providerId: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly connectedEmail: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly connectedAt: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly scopesJson: FieldRef<"CredentialOAuth2Material", 'String'>
    readonly updatedAt: FieldRef<"CredentialOAuth2Material", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CredentialOAuth2Material findUnique
   */
  export type CredentialOAuth2MaterialFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * Filter, which CredentialOAuth2Material to fetch.
     */
    where: CredentialOAuth2MaterialWhereUniqueInput
  }

  /**
   * CredentialOAuth2Material findUniqueOrThrow
   */
  export type CredentialOAuth2MaterialFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * Filter, which CredentialOAuth2Material to fetch.
     */
    where: CredentialOAuth2MaterialWhereUniqueInput
  }

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

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

  /**
   * CredentialOAuth2Material findMany
   */
  export type CredentialOAuth2MaterialFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * Filter, which CredentialOAuth2Materials to fetch.
     */
    where?: CredentialOAuth2MaterialWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialOAuth2Materials to fetch.
     */
    orderBy?: CredentialOAuth2MaterialOrderByWithRelationInput | CredentialOAuth2MaterialOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CredentialOAuth2Materials.
     */
    cursor?: CredentialOAuth2MaterialWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialOAuth2Materials 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` CredentialOAuth2Materials.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CredentialOAuth2Materials.
     */
    distinct?: CredentialOAuth2MaterialScalarFieldEnum | CredentialOAuth2MaterialScalarFieldEnum[]
  }

  /**
   * CredentialOAuth2Material create
   */
  export type CredentialOAuth2MaterialCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * The data needed to create a CredentialOAuth2Material.
     */
    data: XOR<CredentialOAuth2MaterialCreateInput, CredentialOAuth2MaterialUncheckedCreateInput>
  }

  /**
   * CredentialOAuth2Material createMany
   */
  export type CredentialOAuth2MaterialCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CredentialOAuth2Materials.
     */
    data: CredentialOAuth2MaterialCreateManyInput | CredentialOAuth2MaterialCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialOAuth2Material createManyAndReturn
   */
  export type CredentialOAuth2MaterialCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * The data used to create many CredentialOAuth2Materials.
     */
    data: CredentialOAuth2MaterialCreateManyInput | CredentialOAuth2MaterialCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialOAuth2Material update
   */
  export type CredentialOAuth2MaterialUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * The data needed to update a CredentialOAuth2Material.
     */
    data: XOR<CredentialOAuth2MaterialUpdateInput, CredentialOAuth2MaterialUncheckedUpdateInput>
    /**
     * Choose, which CredentialOAuth2Material to update.
     */
    where: CredentialOAuth2MaterialWhereUniqueInput
  }

  /**
   * CredentialOAuth2Material updateMany
   */
  export type CredentialOAuth2MaterialUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CredentialOAuth2Materials.
     */
    data: XOR<CredentialOAuth2MaterialUpdateManyMutationInput, CredentialOAuth2MaterialUncheckedUpdateManyInput>
    /**
     * Filter which CredentialOAuth2Materials to update
     */
    where?: CredentialOAuth2MaterialWhereInput
    /**
     * Limit how many CredentialOAuth2Materials to update.
     */
    limit?: number
  }

  /**
   * CredentialOAuth2Material updateManyAndReturn
   */
  export type CredentialOAuth2MaterialUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * The data used to update CredentialOAuth2Materials.
     */
    data: XOR<CredentialOAuth2MaterialUpdateManyMutationInput, CredentialOAuth2MaterialUncheckedUpdateManyInput>
    /**
     * Filter which CredentialOAuth2Materials to update
     */
    where?: CredentialOAuth2MaterialWhereInput
    /**
     * Limit how many CredentialOAuth2Materials to update.
     */
    limit?: number
  }

  /**
   * CredentialOAuth2Material upsert
   */
  export type CredentialOAuth2MaterialUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * The filter to search for the CredentialOAuth2Material to update in case it exists.
     */
    where: CredentialOAuth2MaterialWhereUniqueInput
    /**
     * In case the CredentialOAuth2Material found by the `where` argument doesn't exist, create a new CredentialOAuth2Material with this data.
     */
    create: XOR<CredentialOAuth2MaterialCreateInput, CredentialOAuth2MaterialUncheckedCreateInput>
    /**
     * In case the CredentialOAuth2Material was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CredentialOAuth2MaterialUpdateInput, CredentialOAuth2MaterialUncheckedUpdateInput>
  }

  /**
   * CredentialOAuth2Material delete
   */
  export type CredentialOAuth2MaterialDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2Material
     */
    select?: CredentialOAuth2MaterialSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2Material
     */
    omit?: CredentialOAuth2MaterialOmit<ExtArgs> | null
    /**
     * Filter which CredentialOAuth2Material to delete.
     */
    where: CredentialOAuth2MaterialWhereUniqueInput
  }

  /**
   * CredentialOAuth2Material deleteMany
   */
  export type CredentialOAuth2MaterialDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialOAuth2Materials to delete
     */
    where?: CredentialOAuth2MaterialWhereInput
    /**
     * Limit how many CredentialOAuth2Materials to delete.
     */
    limit?: number
  }

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


  /**
   * Model CredentialOAuth2State
   */

  export type AggregateCredentialOAuth2State = {
    _count: CredentialOAuth2StateCountAggregateOutputType | null
    _min: CredentialOAuth2StateMinAggregateOutputType | null
    _max: CredentialOAuth2StateMaxAggregateOutputType | null
  }

  export type CredentialOAuth2StateMinAggregateOutputType = {
    state: string | null
    instanceId: string | null
    codeVerifier: string | null
    providerId: string | null
    requestedScopesJson: string | null
    createdAt: string | null
    expiresAt: string | null
  }

  export type CredentialOAuth2StateMaxAggregateOutputType = {
    state: string | null
    instanceId: string | null
    codeVerifier: string | null
    providerId: string | null
    requestedScopesJson: string | null
    createdAt: string | null
    expiresAt: string | null
  }

  export type CredentialOAuth2StateCountAggregateOutputType = {
    state: number
    instanceId: number
    codeVerifier: number
    providerId: number
    requestedScopesJson: number
    createdAt: number
    expiresAt: number
    _all: number
  }


  export type CredentialOAuth2StateMinAggregateInputType = {
    state?: true
    instanceId?: true
    codeVerifier?: true
    providerId?: true
    requestedScopesJson?: true
    createdAt?: true
    expiresAt?: true
  }

  export type CredentialOAuth2StateMaxAggregateInputType = {
    state?: true
    instanceId?: true
    codeVerifier?: true
    providerId?: true
    requestedScopesJson?: true
    createdAt?: true
    expiresAt?: true
  }

  export type CredentialOAuth2StateCountAggregateInputType = {
    state?: true
    instanceId?: true
    codeVerifier?: true
    providerId?: true
    requestedScopesJson?: true
    createdAt?: true
    expiresAt?: true
    _all?: true
  }

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

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




  export type CredentialOAuth2StateGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CredentialOAuth2StateWhereInput
    orderBy?: CredentialOAuth2StateOrderByWithAggregationInput | CredentialOAuth2StateOrderByWithAggregationInput[]
    by: CredentialOAuth2StateScalarFieldEnum[] | CredentialOAuth2StateScalarFieldEnum
    having?: CredentialOAuth2StateScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CredentialOAuth2StateCountAggregateInputType | true
    _min?: CredentialOAuth2StateMinAggregateInputType
    _max?: CredentialOAuth2StateMaxAggregateInputType
  }

  export type CredentialOAuth2StateGroupByOutputType = {
    state: string
    instanceId: string
    codeVerifier: string | null
    providerId: string | null
    requestedScopesJson: string
    createdAt: string
    expiresAt: string
    _count: CredentialOAuth2StateCountAggregateOutputType | null
    _min: CredentialOAuth2StateMinAggregateOutputType | null
    _max: CredentialOAuth2StateMaxAggregateOutputType | null
  }

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


  export type CredentialOAuth2StateSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    state?: boolean
    instanceId?: boolean
    codeVerifier?: boolean
    providerId?: boolean
    requestedScopesJson?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["credentialOAuth2State"]>

  export type CredentialOAuth2StateSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    state?: boolean
    instanceId?: boolean
    codeVerifier?: boolean
    providerId?: boolean
    requestedScopesJson?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["credentialOAuth2State"]>

  export type CredentialOAuth2StateSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    state?: boolean
    instanceId?: boolean
    codeVerifier?: boolean
    providerId?: boolean
    requestedScopesJson?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["credentialOAuth2State"]>

  export type CredentialOAuth2StateSelectScalar = {
    state?: boolean
    instanceId?: boolean
    codeVerifier?: boolean
    providerId?: boolean
    requestedScopesJson?: boolean
    createdAt?: boolean
    expiresAt?: boolean
  }

  export type CredentialOAuth2StateOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"state" | "instanceId" | "codeVerifier" | "providerId" | "requestedScopesJson" | "createdAt" | "expiresAt", ExtArgs["result"]["credentialOAuth2State"]>

  export type $CredentialOAuth2StatePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CredentialOAuth2State"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      state: string
      instanceId: string
      codeVerifier: string | null
      providerId: string | null
      requestedScopesJson: string
      createdAt: string
      expiresAt: string
    }, ExtArgs["result"]["credentialOAuth2State"]>
    composites: {}
  }

  type CredentialOAuth2StateGetPayload<S extends boolean | null | undefined | CredentialOAuth2StateDefaultArgs> = $Result.GetResult<Prisma.$CredentialOAuth2StatePayload, S>

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

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

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

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

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

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

    /**
     * Create a CredentialOAuth2State.
     * @param {CredentialOAuth2StateCreateArgs} args - Arguments to create a CredentialOAuth2State.
     * @example
     * // Create one CredentialOAuth2State
     * const CredentialOAuth2State = await prisma.credentialOAuth2State.create({
     *   data: {
     *     // ... data to create a CredentialOAuth2State
     *   }
     * })
     * 
     */
    create<T extends CredentialOAuth2StateCreateArgs>(args: SelectSubset<T, CredentialOAuth2StateCreateArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CredentialOAuth2States and returns the data saved in the database.
     * @param {CredentialOAuth2StateCreateManyAndReturnArgs} args - Arguments to create many CredentialOAuth2States.
     * @example
     * // Create many CredentialOAuth2States
     * const credentialOAuth2State = await prisma.credentialOAuth2State.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CredentialOAuth2States and only return the `state`
     * const credentialOAuth2StateWithStateOnly = await prisma.credentialOAuth2State.createManyAndReturn({
     *   select: { state: 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 CredentialOAuth2StateCreateManyAndReturnArgs>(args?: SelectSubset<T, CredentialOAuth2StateCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CredentialOAuth2State.
     * @param {CredentialOAuth2StateDeleteArgs} args - Arguments to delete one CredentialOAuth2State.
     * @example
     * // Delete one CredentialOAuth2State
     * const CredentialOAuth2State = await prisma.credentialOAuth2State.delete({
     *   where: {
     *     // ... filter to delete one CredentialOAuth2State
     *   }
     * })
     * 
     */
    delete<T extends CredentialOAuth2StateDeleteArgs>(args: SelectSubset<T, CredentialOAuth2StateDeleteArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the CredentialOAuth2State model
   */
  interface CredentialOAuth2StateFieldRefs {
    readonly state: FieldRef<"CredentialOAuth2State", 'String'>
    readonly instanceId: FieldRef<"CredentialOAuth2State", 'String'>
    readonly codeVerifier: FieldRef<"CredentialOAuth2State", 'String'>
    readonly providerId: FieldRef<"CredentialOAuth2State", 'String'>
    readonly requestedScopesJson: FieldRef<"CredentialOAuth2State", 'String'>
    readonly createdAt: FieldRef<"CredentialOAuth2State", 'String'>
    readonly expiresAt: FieldRef<"CredentialOAuth2State", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CredentialOAuth2State findUnique
   */
  export type CredentialOAuth2StateFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * Filter, which CredentialOAuth2State to fetch.
     */
    where: CredentialOAuth2StateWhereUniqueInput
  }

  /**
   * CredentialOAuth2State findUniqueOrThrow
   */
  export type CredentialOAuth2StateFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * Filter, which CredentialOAuth2State to fetch.
     */
    where: CredentialOAuth2StateWhereUniqueInput
  }

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

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

  /**
   * CredentialOAuth2State findMany
   */
  export type CredentialOAuth2StateFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * Filter, which CredentialOAuth2States to fetch.
     */
    where?: CredentialOAuth2StateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialOAuth2States to fetch.
     */
    orderBy?: CredentialOAuth2StateOrderByWithRelationInput | CredentialOAuth2StateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CredentialOAuth2States.
     */
    cursor?: CredentialOAuth2StateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialOAuth2States 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` CredentialOAuth2States.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CredentialOAuth2States.
     */
    distinct?: CredentialOAuth2StateScalarFieldEnum | CredentialOAuth2StateScalarFieldEnum[]
  }

  /**
   * CredentialOAuth2State create
   */
  export type CredentialOAuth2StateCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * The data needed to create a CredentialOAuth2State.
     */
    data: XOR<CredentialOAuth2StateCreateInput, CredentialOAuth2StateUncheckedCreateInput>
  }

  /**
   * CredentialOAuth2State createMany
   */
  export type CredentialOAuth2StateCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CredentialOAuth2States.
     */
    data: CredentialOAuth2StateCreateManyInput | CredentialOAuth2StateCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialOAuth2State createManyAndReturn
   */
  export type CredentialOAuth2StateCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * The data used to create many CredentialOAuth2States.
     */
    data: CredentialOAuth2StateCreateManyInput | CredentialOAuth2StateCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialOAuth2State update
   */
  export type CredentialOAuth2StateUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * The data needed to update a CredentialOAuth2State.
     */
    data: XOR<CredentialOAuth2StateUpdateInput, CredentialOAuth2StateUncheckedUpdateInput>
    /**
     * Choose, which CredentialOAuth2State to update.
     */
    where: CredentialOAuth2StateWhereUniqueInput
  }

  /**
   * CredentialOAuth2State updateMany
   */
  export type CredentialOAuth2StateUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CredentialOAuth2States.
     */
    data: XOR<CredentialOAuth2StateUpdateManyMutationInput, CredentialOAuth2StateUncheckedUpdateManyInput>
    /**
     * Filter which CredentialOAuth2States to update
     */
    where?: CredentialOAuth2StateWhereInput
    /**
     * Limit how many CredentialOAuth2States to update.
     */
    limit?: number
  }

  /**
   * CredentialOAuth2State updateManyAndReturn
   */
  export type CredentialOAuth2StateUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * The data used to update CredentialOAuth2States.
     */
    data: XOR<CredentialOAuth2StateUpdateManyMutationInput, CredentialOAuth2StateUncheckedUpdateManyInput>
    /**
     * Filter which CredentialOAuth2States to update
     */
    where?: CredentialOAuth2StateWhereInput
    /**
     * Limit how many CredentialOAuth2States to update.
     */
    limit?: number
  }

  /**
   * CredentialOAuth2State upsert
   */
  export type CredentialOAuth2StateUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * The filter to search for the CredentialOAuth2State to update in case it exists.
     */
    where: CredentialOAuth2StateWhereUniqueInput
    /**
     * In case the CredentialOAuth2State found by the `where` argument doesn't exist, create a new CredentialOAuth2State with this data.
     */
    create: XOR<CredentialOAuth2StateCreateInput, CredentialOAuth2StateUncheckedCreateInput>
    /**
     * In case the CredentialOAuth2State was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CredentialOAuth2StateUpdateInput, CredentialOAuth2StateUncheckedUpdateInput>
  }

  /**
   * CredentialOAuth2State delete
   */
  export type CredentialOAuth2StateDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialOAuth2State
     */
    select?: CredentialOAuth2StateSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialOAuth2State
     */
    omit?: CredentialOAuth2StateOmit<ExtArgs> | null
    /**
     * Filter which CredentialOAuth2State to delete.
     */
    where: CredentialOAuth2StateWhereUniqueInput
  }

  /**
   * CredentialOAuth2State deleteMany
   */
  export type CredentialOAuth2StateDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialOAuth2States to delete
     */
    where?: CredentialOAuth2StateWhereInput
    /**
     * Limit how many CredentialOAuth2States to delete.
     */
    limit?: number
  }

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


  /**
   * Model CredentialBinding
   */

  export type AggregateCredentialBinding = {
    _count: CredentialBindingCountAggregateOutputType | null
    _min: CredentialBindingMinAggregateOutputType | null
    _max: CredentialBindingMaxAggregateOutputType | null
  }

  export type CredentialBindingMinAggregateOutputType = {
    workflowId: string | null
    nodeId: string | null
    slotKey: string | null
    instanceId: string | null
    updatedAt: string | null
  }

  export type CredentialBindingMaxAggregateOutputType = {
    workflowId: string | null
    nodeId: string | null
    slotKey: string | null
    instanceId: string | null
    updatedAt: string | null
  }

  export type CredentialBindingCountAggregateOutputType = {
    workflowId: number
    nodeId: number
    slotKey: number
    instanceId: number
    updatedAt: number
    _all: number
  }


  export type CredentialBindingMinAggregateInputType = {
    workflowId?: true
    nodeId?: true
    slotKey?: true
    instanceId?: true
    updatedAt?: true
  }

  export type CredentialBindingMaxAggregateInputType = {
    workflowId?: true
    nodeId?: true
    slotKey?: true
    instanceId?: true
    updatedAt?: true
  }

  export type CredentialBindingCountAggregateInputType = {
    workflowId?: true
    nodeId?: true
    slotKey?: true
    instanceId?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type CredentialBindingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CredentialBindingWhereInput
    orderBy?: CredentialBindingOrderByWithAggregationInput | CredentialBindingOrderByWithAggregationInput[]
    by: CredentialBindingScalarFieldEnum[] | CredentialBindingScalarFieldEnum
    having?: CredentialBindingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CredentialBindingCountAggregateInputType | true
    _min?: CredentialBindingMinAggregateInputType
    _max?: CredentialBindingMaxAggregateInputType
  }

  export type CredentialBindingGroupByOutputType = {
    workflowId: string
    nodeId: string
    slotKey: string
    instanceId: string
    updatedAt: string
    _count: CredentialBindingCountAggregateOutputType | null
    _min: CredentialBindingMinAggregateOutputType | null
    _max: CredentialBindingMaxAggregateOutputType | null
  }

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


  export type CredentialBindingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    nodeId?: boolean
    slotKey?: boolean
    instanceId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialBinding"]>

  export type CredentialBindingSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    nodeId?: boolean
    slotKey?: boolean
    instanceId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialBinding"]>

  export type CredentialBindingSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    workflowId?: boolean
    nodeId?: boolean
    slotKey?: boolean
    instanceId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["credentialBinding"]>

  export type CredentialBindingSelectScalar = {
    workflowId?: boolean
    nodeId?: boolean
    slotKey?: boolean
    instanceId?: boolean
    updatedAt?: boolean
  }

  export type CredentialBindingOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"workflowId" | "nodeId" | "slotKey" | "instanceId" | "updatedAt", ExtArgs["result"]["credentialBinding"]>

  export type $CredentialBindingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CredentialBinding"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      workflowId: string
      nodeId: string
      slotKey: string
      instanceId: string
      updatedAt: string
    }, ExtArgs["result"]["credentialBinding"]>
    composites: {}
  }

  type CredentialBindingGetPayload<S extends boolean | null | undefined | CredentialBindingDefaultArgs> = $Result.GetResult<Prisma.$CredentialBindingPayload, S>

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

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

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

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

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

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

    /**
     * Create a CredentialBinding.
     * @param {CredentialBindingCreateArgs} args - Arguments to create a CredentialBinding.
     * @example
     * // Create one CredentialBinding
     * const CredentialBinding = await prisma.credentialBinding.create({
     *   data: {
     *     // ... data to create a CredentialBinding
     *   }
     * })
     * 
     */
    create<T extends CredentialBindingCreateArgs>(args: SelectSubset<T, CredentialBindingCreateArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CredentialBindings and returns the data saved in the database.
     * @param {CredentialBindingCreateManyAndReturnArgs} args - Arguments to create many CredentialBindings.
     * @example
     * // Create many CredentialBindings
     * const credentialBinding = await prisma.credentialBinding.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CredentialBindings and only return the `workflowId`
     * const credentialBindingWithWorkflowIdOnly = await prisma.credentialBinding.createManyAndReturn({
     *   select: { workflowId: 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 CredentialBindingCreateManyAndReturnArgs>(args?: SelectSubset<T, CredentialBindingCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CredentialBinding.
     * @param {CredentialBindingDeleteArgs} args - Arguments to delete one CredentialBinding.
     * @example
     * // Delete one CredentialBinding
     * const CredentialBinding = await prisma.credentialBinding.delete({
     *   where: {
     *     // ... filter to delete one CredentialBinding
     *   }
     * })
     * 
     */
    delete<T extends CredentialBindingDeleteArgs>(args: SelectSubset<T, CredentialBindingDeleteArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the CredentialBinding model
   */
  interface CredentialBindingFieldRefs {
    readonly workflowId: FieldRef<"CredentialBinding", 'String'>
    readonly nodeId: FieldRef<"CredentialBinding", 'String'>
    readonly slotKey: FieldRef<"CredentialBinding", 'String'>
    readonly instanceId: FieldRef<"CredentialBinding", 'String'>
    readonly updatedAt: FieldRef<"CredentialBinding", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CredentialBinding findUnique
   */
  export type CredentialBindingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * Filter, which CredentialBinding to fetch.
     */
    where: CredentialBindingWhereUniqueInput
  }

  /**
   * CredentialBinding findUniqueOrThrow
   */
  export type CredentialBindingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * Filter, which CredentialBinding to fetch.
     */
    where: CredentialBindingWhereUniqueInput
  }

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

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

  /**
   * CredentialBinding findMany
   */
  export type CredentialBindingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * Filter, which CredentialBindings to fetch.
     */
    where?: CredentialBindingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialBindings to fetch.
     */
    orderBy?: CredentialBindingOrderByWithRelationInput | CredentialBindingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CredentialBindings.
     */
    cursor?: CredentialBindingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialBindings 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` CredentialBindings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CredentialBindings.
     */
    distinct?: CredentialBindingScalarFieldEnum | CredentialBindingScalarFieldEnum[]
  }

  /**
   * CredentialBinding create
   */
  export type CredentialBindingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * The data needed to create a CredentialBinding.
     */
    data: XOR<CredentialBindingCreateInput, CredentialBindingUncheckedCreateInput>
  }

  /**
   * CredentialBinding createMany
   */
  export type CredentialBindingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CredentialBindings.
     */
    data: CredentialBindingCreateManyInput | CredentialBindingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialBinding createManyAndReturn
   */
  export type CredentialBindingCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * The data used to create many CredentialBindings.
     */
    data: CredentialBindingCreateManyInput | CredentialBindingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialBinding update
   */
  export type CredentialBindingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * The data needed to update a CredentialBinding.
     */
    data: XOR<CredentialBindingUpdateInput, CredentialBindingUncheckedUpdateInput>
    /**
     * Choose, which CredentialBinding to update.
     */
    where: CredentialBindingWhereUniqueInput
  }

  /**
   * CredentialBinding updateMany
   */
  export type CredentialBindingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CredentialBindings.
     */
    data: XOR<CredentialBindingUpdateManyMutationInput, CredentialBindingUncheckedUpdateManyInput>
    /**
     * Filter which CredentialBindings to update
     */
    where?: CredentialBindingWhereInput
    /**
     * Limit how many CredentialBindings to update.
     */
    limit?: number
  }

  /**
   * CredentialBinding updateManyAndReturn
   */
  export type CredentialBindingUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * The data used to update CredentialBindings.
     */
    data: XOR<CredentialBindingUpdateManyMutationInput, CredentialBindingUncheckedUpdateManyInput>
    /**
     * Filter which CredentialBindings to update
     */
    where?: CredentialBindingWhereInput
    /**
     * Limit how many CredentialBindings to update.
     */
    limit?: number
  }

  /**
   * CredentialBinding upsert
   */
  export type CredentialBindingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * The filter to search for the CredentialBinding to update in case it exists.
     */
    where: CredentialBindingWhereUniqueInput
    /**
     * In case the CredentialBinding found by the `where` argument doesn't exist, create a new CredentialBinding with this data.
     */
    create: XOR<CredentialBindingCreateInput, CredentialBindingUncheckedCreateInput>
    /**
     * In case the CredentialBinding was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CredentialBindingUpdateInput, CredentialBindingUncheckedUpdateInput>
  }

  /**
   * CredentialBinding delete
   */
  export type CredentialBindingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialBinding
     */
    select?: CredentialBindingSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialBinding
     */
    omit?: CredentialBindingOmit<ExtArgs> | null
    /**
     * Filter which CredentialBinding to delete.
     */
    where: CredentialBindingWhereUniqueInput
  }

  /**
   * CredentialBinding deleteMany
   */
  export type CredentialBindingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialBindings to delete
     */
    where?: CredentialBindingWhereInput
    /**
     * Limit how many CredentialBindings to delete.
     */
    limit?: number
  }

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


  /**
   * Model CredentialTestResult
   */

  export type AggregateCredentialTestResult = {
    _count: CredentialTestResultCountAggregateOutputType | null
    _min: CredentialTestResultMinAggregateOutputType | null
    _max: CredentialTestResultMaxAggregateOutputType | null
  }

  export type CredentialTestResultMinAggregateOutputType = {
    testId: string | null
    instanceId: string | null
    status: string | null
    message: string | null
    detailsJson: string | null
    testedAt: string | null
    expiresAt: string | null
  }

  export type CredentialTestResultMaxAggregateOutputType = {
    testId: string | null
    instanceId: string | null
    status: string | null
    message: string | null
    detailsJson: string | null
    testedAt: string | null
    expiresAt: string | null
  }

  export type CredentialTestResultCountAggregateOutputType = {
    testId: number
    instanceId: number
    status: number
    message: number
    detailsJson: number
    testedAt: number
    expiresAt: number
    _all: number
  }


  export type CredentialTestResultMinAggregateInputType = {
    testId?: true
    instanceId?: true
    status?: true
    message?: true
    detailsJson?: true
    testedAt?: true
    expiresAt?: true
  }

  export type CredentialTestResultMaxAggregateInputType = {
    testId?: true
    instanceId?: true
    status?: true
    message?: true
    detailsJson?: true
    testedAt?: true
    expiresAt?: true
  }

  export type CredentialTestResultCountAggregateInputType = {
    testId?: true
    instanceId?: true
    status?: true
    message?: true
    detailsJson?: true
    testedAt?: true
    expiresAt?: true
    _all?: true
  }

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

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




  export type CredentialTestResultGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CredentialTestResultWhereInput
    orderBy?: CredentialTestResultOrderByWithAggregationInput | CredentialTestResultOrderByWithAggregationInput[]
    by: CredentialTestResultScalarFieldEnum[] | CredentialTestResultScalarFieldEnum
    having?: CredentialTestResultScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CredentialTestResultCountAggregateInputType | true
    _min?: CredentialTestResultMinAggregateInputType
    _max?: CredentialTestResultMaxAggregateInputType
  }

  export type CredentialTestResultGroupByOutputType = {
    testId: string
    instanceId: string
    status: string
    message: string | null
    detailsJson: string
    testedAt: string
    expiresAt: string | null
    _count: CredentialTestResultCountAggregateOutputType | null
    _min: CredentialTestResultMinAggregateOutputType | null
    _max: CredentialTestResultMaxAggregateOutputType | null
  }

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


  export type CredentialTestResultSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    testId?: boolean
    instanceId?: boolean
    status?: boolean
    message?: boolean
    detailsJson?: boolean
    testedAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["credentialTestResult"]>

  export type CredentialTestResultSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    testId?: boolean
    instanceId?: boolean
    status?: boolean
    message?: boolean
    detailsJson?: boolean
    testedAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["credentialTestResult"]>

  export type CredentialTestResultSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    testId?: boolean
    instanceId?: boolean
    status?: boolean
    message?: boolean
    detailsJson?: boolean
    testedAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["credentialTestResult"]>

  export type CredentialTestResultSelectScalar = {
    testId?: boolean
    instanceId?: boolean
    status?: boolean
    message?: boolean
    detailsJson?: boolean
    testedAt?: boolean
    expiresAt?: boolean
  }

  export type CredentialTestResultOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"testId" | "instanceId" | "status" | "message" | "detailsJson" | "testedAt" | "expiresAt", ExtArgs["result"]["credentialTestResult"]>

  export type $CredentialTestResultPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CredentialTestResult"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      testId: string
      instanceId: string
      status: string
      message: string | null
      detailsJson: string
      testedAt: string
      expiresAt: string | null
    }, ExtArgs["result"]["credentialTestResult"]>
    composites: {}
  }

  type CredentialTestResultGetPayload<S extends boolean | null | undefined | CredentialTestResultDefaultArgs> = $Result.GetResult<Prisma.$CredentialTestResultPayload, S>

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

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

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

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

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

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

    /**
     * Create a CredentialTestResult.
     * @param {CredentialTestResultCreateArgs} args - Arguments to create a CredentialTestResult.
     * @example
     * // Create one CredentialTestResult
     * const CredentialTestResult = await prisma.credentialTestResult.create({
     *   data: {
     *     // ... data to create a CredentialTestResult
     *   }
     * })
     * 
     */
    create<T extends CredentialTestResultCreateArgs>(args: SelectSubset<T, CredentialTestResultCreateArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many CredentialTestResults and returns the data saved in the database.
     * @param {CredentialTestResultCreateManyAndReturnArgs} args - Arguments to create many CredentialTestResults.
     * @example
     * // Create many CredentialTestResults
     * const credentialTestResult = await prisma.credentialTestResult.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CredentialTestResults and only return the `testId`
     * const credentialTestResultWithTestIdOnly = await prisma.credentialTestResult.createManyAndReturn({
     *   select: { testId: 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 CredentialTestResultCreateManyAndReturnArgs>(args?: SelectSubset<T, CredentialTestResultCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a CredentialTestResult.
     * @param {CredentialTestResultDeleteArgs} args - Arguments to delete one CredentialTestResult.
     * @example
     * // Delete one CredentialTestResult
     * const CredentialTestResult = await prisma.credentialTestResult.delete({
     *   where: {
     *     // ... filter to delete one CredentialTestResult
     *   }
     * })
     * 
     */
    delete<T extends CredentialTestResultDeleteArgs>(args: SelectSubset<T, CredentialTestResultDeleteArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the CredentialTestResult model
   */
  interface CredentialTestResultFieldRefs {
    readonly testId: FieldRef<"CredentialTestResult", 'String'>
    readonly instanceId: FieldRef<"CredentialTestResult", 'String'>
    readonly status: FieldRef<"CredentialTestResult", 'String'>
    readonly message: FieldRef<"CredentialTestResult", 'String'>
    readonly detailsJson: FieldRef<"CredentialTestResult", 'String'>
    readonly testedAt: FieldRef<"CredentialTestResult", 'String'>
    readonly expiresAt: FieldRef<"CredentialTestResult", 'String'>
  }
    

  // Custom InputTypes
  /**
   * CredentialTestResult findUnique
   */
  export type CredentialTestResultFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * Filter, which CredentialTestResult to fetch.
     */
    where: CredentialTestResultWhereUniqueInput
  }

  /**
   * CredentialTestResult findUniqueOrThrow
   */
  export type CredentialTestResultFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * Filter, which CredentialTestResult to fetch.
     */
    where: CredentialTestResultWhereUniqueInput
  }

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

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

  /**
   * CredentialTestResult findMany
   */
  export type CredentialTestResultFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * Filter, which CredentialTestResults to fetch.
     */
    where?: CredentialTestResultWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CredentialTestResults to fetch.
     */
    orderBy?: CredentialTestResultOrderByWithRelationInput | CredentialTestResultOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CredentialTestResults.
     */
    cursor?: CredentialTestResultWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CredentialTestResults 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` CredentialTestResults.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CredentialTestResults.
     */
    distinct?: CredentialTestResultScalarFieldEnum | CredentialTestResultScalarFieldEnum[]
  }

  /**
   * CredentialTestResult create
   */
  export type CredentialTestResultCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * The data needed to create a CredentialTestResult.
     */
    data: XOR<CredentialTestResultCreateInput, CredentialTestResultUncheckedCreateInput>
  }

  /**
   * CredentialTestResult createMany
   */
  export type CredentialTestResultCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CredentialTestResults.
     */
    data: CredentialTestResultCreateManyInput | CredentialTestResultCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialTestResult createManyAndReturn
   */
  export type CredentialTestResultCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * The data used to create many CredentialTestResults.
     */
    data: CredentialTestResultCreateManyInput | CredentialTestResultCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CredentialTestResult update
   */
  export type CredentialTestResultUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * The data needed to update a CredentialTestResult.
     */
    data: XOR<CredentialTestResultUpdateInput, CredentialTestResultUncheckedUpdateInput>
    /**
     * Choose, which CredentialTestResult to update.
     */
    where: CredentialTestResultWhereUniqueInput
  }

  /**
   * CredentialTestResult updateMany
   */
  export type CredentialTestResultUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CredentialTestResults.
     */
    data: XOR<CredentialTestResultUpdateManyMutationInput, CredentialTestResultUncheckedUpdateManyInput>
    /**
     * Filter which CredentialTestResults to update
     */
    where?: CredentialTestResultWhereInput
    /**
     * Limit how many CredentialTestResults to update.
     */
    limit?: number
  }

  /**
   * CredentialTestResult updateManyAndReturn
   */
  export type CredentialTestResultUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * The data used to update CredentialTestResults.
     */
    data: XOR<CredentialTestResultUpdateManyMutationInput, CredentialTestResultUncheckedUpdateManyInput>
    /**
     * Filter which CredentialTestResults to update
     */
    where?: CredentialTestResultWhereInput
    /**
     * Limit how many CredentialTestResults to update.
     */
    limit?: number
  }

  /**
   * CredentialTestResult upsert
   */
  export type CredentialTestResultUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * The filter to search for the CredentialTestResult to update in case it exists.
     */
    where: CredentialTestResultWhereUniqueInput
    /**
     * In case the CredentialTestResult found by the `where` argument doesn't exist, create a new CredentialTestResult with this data.
     */
    create: XOR<CredentialTestResultCreateInput, CredentialTestResultUncheckedCreateInput>
    /**
     * In case the CredentialTestResult was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CredentialTestResultUpdateInput, CredentialTestResultUncheckedUpdateInput>
  }

  /**
   * CredentialTestResult delete
   */
  export type CredentialTestResultDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CredentialTestResult
     */
    select?: CredentialTestResultSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CredentialTestResult
     */
    omit?: CredentialTestResultOmit<ExtArgs> | null
    /**
     * Filter which CredentialTestResult to delete.
     */
    where: CredentialTestResultWhereUniqueInput
  }

  /**
   * CredentialTestResult deleteMany
   */
  export type CredentialTestResultDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CredentialTestResults to delete
     */
    where?: CredentialTestResultWhereInput
    /**
     * Limit how many CredentialTestResults to delete.
     */
    limit?: number
  }

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


  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    emailVerified: boolean | null
    image: string | null
    passwordHash: string | null
    accountStatus: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    emailVerified: boolean | null
    image: string | null
    passwordHash: string | null
    accountStatus: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    name: number
    email: number
    emailVerified: number
    image: number
    passwordHash: number
    accountStatus: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    name?: true
    email?: true
    emailVerified?: true
    image?: true
    passwordHash?: true
    accountStatus?: true
    createdAt?: true
    updatedAt?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    name?: true
    email?: true
    emailVerified?: true
    image?: true
    passwordHash?: true
    accountStatus?: true
    createdAt?: true
    updatedAt?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    name?: true
    email?: true
    emailVerified?: true
    image?: true
    passwordHash?: true
    accountStatus?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which User to aggregate.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Users
    **/
    _count?: true | UserCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserMaxAggregateInputType
  }

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




  export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserWhereInput
    orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
    by: UserScalarFieldEnum[] | UserScalarFieldEnum
    having?: UserScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserCountAggregateInputType | true
    _min?: UserMinAggregateInputType
    _max?: UserMaxAggregateInputType
  }

  export type UserGroupByOutputType = {
    id: string
    name: string | null
    email: string | null
    emailVerified: boolean
    image: string | null
    passwordHash: string | null
    accountStatus: string
    createdAt: Date
    updatedAt: Date
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

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


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    emailVerified?: boolean
    image?: boolean
    passwordHash?: boolean
    accountStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    accounts?: boolean | User$accountsArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    invites?: boolean | User$invitesArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    emailVerified?: boolean
    image?: boolean
    passwordHash?: boolean
    accountStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    emailVerified?: boolean
    image?: boolean
    passwordHash?: boolean
    accountStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    name?: boolean
    email?: boolean
    emailVerified?: boolean
    image?: boolean
    passwordHash?: boolean
    accountStatus?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "email" | "emailVerified" | "image" | "passwordHash" | "accountStatus" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]>
  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accounts?: boolean | User$accountsArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    invites?: boolean | User$invitesArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type UserIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      accounts: Prisma.$AccountPayload<ExtArgs>[]
      sessions: Prisma.$SessionPayload<ExtArgs>[]
      invites: Prisma.$UserInvitePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      email: string | null
      emailVerified: boolean
      image: string | null
      passwordHash: string | null
      /**
       * invited | active | inactive (local directory / invite flow)
       */
      accountStatus: string
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

  type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>

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

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

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

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

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

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

    /**
     * Create a User.
     * @param {UserCreateArgs} args - Arguments to create a User.
     * @example
     * // Create one User
     * const User = await prisma.user.create({
     *   data: {
     *     // ... data to create a User
     *   }
     * })
     * 
     */
    create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Delete a User.
     * @param {UserDeleteArgs} args - Arguments to delete one User.
     * @example
     * // Delete one User
     * const User = await prisma.user.delete({
     *   where: {
     *     // ... filter to delete one User
     *   }
     * })
     * 
     */
    delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for User.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    accounts<T extends User$accountsArgs<ExtArgs> = {}>(args?: Subset<T, User$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    sessions<T extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    invites<T extends User$invitesArgs<ExtArgs> = {}>(args?: Subset<T, User$invitesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the User model
   */
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'String'>
    readonly name: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly emailVerified: FieldRef<"User", 'Boolean'>
    readonly image: FieldRef<"User", 'String'>
    readonly passwordHash: FieldRef<"User", 'String'>
    readonly accountStatus: FieldRef<"User", 'String'>
    readonly createdAt: FieldRef<"User", 'DateTime'>
    readonly updatedAt: FieldRef<"User", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * User findUnique
   */
  export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findUniqueOrThrow
   */
  export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findFirst
   */
  export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findFirstOrThrow
   */
  export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findMany
   */
  export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which Users to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User create
   */
  export type UserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The data needed to create a User.
     */
    data: XOR<UserCreateInput, UserUncheckedCreateInput>
  }

  /**
   * User createMany
   */
  export type UserCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Users.
     */
    data: UserCreateManyInput | UserCreateManyInput[]
    skipDuplicates?: boolean
  }

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

  /**
   * User update
   */
  export type UserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The data needed to update a User.
     */
    data: XOR<UserUpdateInput, UserUncheckedUpdateInput>
    /**
     * Choose, which User to update.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User updateMany
   */
  export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to update.
     */
    limit?: number
  }

  /**
   * User updateManyAndReturn
   */
  export type UserUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to update.
     */
    limit?: number
  }

  /**
   * User upsert
   */
  export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The filter to search for the User to update in case it exists.
     */
    where: UserWhereUniqueInput
    /**
     * In case the User found by the `where` argument doesn't exist, create a new User with this data.
     */
    create: XOR<UserCreateInput, UserUncheckedCreateInput>
    /**
     * In case the User was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
  }

  /**
   * User delete
   */
  export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter which User to delete.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User deleteMany
   */
  export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Users to delete
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to delete.
     */
    limit?: number
  }

  /**
   * User.accounts
   */
  export type User$accountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    cursor?: AccountWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

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

  /**
   * User.invites
   */
  export type User$invitesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    where?: UserInviteWhereInput
    orderBy?: UserInviteOrderByWithRelationInput | UserInviteOrderByWithRelationInput[]
    cursor?: UserInviteWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserInviteScalarFieldEnum | UserInviteScalarFieldEnum[]
  }

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


  /**
   * Model UserInvite
   */

  export type AggregateUserInvite = {
    _count: UserInviteCountAggregateOutputType | null
    _min: UserInviteMinAggregateOutputType | null
    _max: UserInviteMaxAggregateOutputType | null
  }

  export type UserInviteMinAggregateOutputType = {
    id: string | null
    userId: string | null
    tokenHash: string | null
    expiresAt: Date | null
    createdAt: Date | null
    revokedAt: Date | null
  }

  export type UserInviteMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    tokenHash: string | null
    expiresAt: Date | null
    createdAt: Date | null
    revokedAt: Date | null
  }

  export type UserInviteCountAggregateOutputType = {
    id: number
    userId: number
    tokenHash: number
    expiresAt: number
    createdAt: number
    revokedAt: number
    _all: number
  }


  export type UserInviteMinAggregateInputType = {
    id?: true
    userId?: true
    tokenHash?: true
    expiresAt?: true
    createdAt?: true
    revokedAt?: true
  }

  export type UserInviteMaxAggregateInputType = {
    id?: true
    userId?: true
    tokenHash?: true
    expiresAt?: true
    createdAt?: true
    revokedAt?: true
  }

  export type UserInviteCountAggregateInputType = {
    id?: true
    userId?: true
    tokenHash?: true
    expiresAt?: true
    createdAt?: true
    revokedAt?: true
    _all?: true
  }

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

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




  export type UserInviteGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserInviteWhereInput
    orderBy?: UserInviteOrderByWithAggregationInput | UserInviteOrderByWithAggregationInput[]
    by: UserInviteScalarFieldEnum[] | UserInviteScalarFieldEnum
    having?: UserInviteScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserInviteCountAggregateInputType | true
    _min?: UserInviteMinAggregateInputType
    _max?: UserInviteMaxAggregateInputType
  }

  export type UserInviteGroupByOutputType = {
    id: string
    userId: string
    tokenHash: string
    expiresAt: Date
    createdAt: Date
    revokedAt: Date | null
    _count: UserInviteCountAggregateOutputType | null
    _min: UserInviteMinAggregateOutputType | null
    _max: UserInviteMaxAggregateOutputType | null
  }

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


  export type UserInviteSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
    revokedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userInvite"]>

  export type UserInviteSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
    revokedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userInvite"]>

  export type UserInviteSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
    revokedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userInvite"]>

  export type UserInviteSelectScalar = {
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
    revokedAt?: boolean
  }

  export type UserInviteOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "tokenHash" | "expiresAt" | "createdAt" | "revokedAt", ExtArgs["result"]["userInvite"]>
  export type UserInviteInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type UserInviteIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type UserInviteIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $UserInvitePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UserInvite"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      tokenHash: string
      expiresAt: Date
      createdAt: Date
      revokedAt: Date | null
    }, ExtArgs["result"]["userInvite"]>
    composites: {}
  }

  type UserInviteGetPayload<S extends boolean | null | undefined | UserInviteDefaultArgs> = $Result.GetResult<Prisma.$UserInvitePayload, S>

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

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

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

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

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

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

    /**
     * Create a UserInvite.
     * @param {UserInviteCreateArgs} args - Arguments to create a UserInvite.
     * @example
     * // Create one UserInvite
     * const UserInvite = await prisma.userInvite.create({
     *   data: {
     *     // ... data to create a UserInvite
     *   }
     * })
     * 
     */
    create<T extends UserInviteCreateArgs>(args: SelectSubset<T, UserInviteCreateArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many UserInvites and returns the data saved in the database.
     * @param {UserInviteCreateManyAndReturnArgs} args - Arguments to create many UserInvites.
     * @example
     * // Create many UserInvites
     * const userInvite = await prisma.userInvite.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many UserInvites and only return the `id`
     * const userInviteWithIdOnly = await prisma.userInvite.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 UserInviteCreateManyAndReturnArgs>(args?: SelectSubset<T, UserInviteCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a UserInvite.
     * @param {UserInviteDeleteArgs} args - Arguments to delete one UserInvite.
     * @example
     * // Delete one UserInvite
     * const UserInvite = await prisma.userInvite.delete({
     *   where: {
     *     // ... filter to delete one UserInvite
     *   }
     * })
     * 
     */
    delete<T extends UserInviteDeleteArgs>(args: SelectSubset<T, UserInviteDeleteArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the UserInvite model
   */
  interface UserInviteFieldRefs {
    readonly id: FieldRef<"UserInvite", 'String'>
    readonly userId: FieldRef<"UserInvite", 'String'>
    readonly tokenHash: FieldRef<"UserInvite", 'String'>
    readonly expiresAt: FieldRef<"UserInvite", 'DateTime'>
    readonly createdAt: FieldRef<"UserInvite", 'DateTime'>
    readonly revokedAt: FieldRef<"UserInvite", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * UserInvite findUnique
   */
  export type UserInviteFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * Filter, which UserInvite to fetch.
     */
    where: UserInviteWhereUniqueInput
  }

  /**
   * UserInvite findUniqueOrThrow
   */
  export type UserInviteFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * Filter, which UserInvite to fetch.
     */
    where: UserInviteWhereUniqueInput
  }

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

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

  /**
   * UserInvite findMany
   */
  export type UserInviteFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * Filter, which UserInvites to fetch.
     */
    where?: UserInviteWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UserInvites to fetch.
     */
    orderBy?: UserInviteOrderByWithRelationInput | UserInviteOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing UserInvites.
     */
    cursor?: UserInviteWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UserInvites 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` UserInvites.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of UserInvites.
     */
    distinct?: UserInviteScalarFieldEnum | UserInviteScalarFieldEnum[]
  }

  /**
   * UserInvite create
   */
  export type UserInviteCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * The data needed to create a UserInvite.
     */
    data: XOR<UserInviteCreateInput, UserInviteUncheckedCreateInput>
  }

  /**
   * UserInvite createMany
   */
  export type UserInviteCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many UserInvites.
     */
    data: UserInviteCreateManyInput | UserInviteCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * UserInvite createManyAndReturn
   */
  export type UserInviteCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * The data used to create many UserInvites.
     */
    data: UserInviteCreateManyInput | UserInviteCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * UserInvite update
   */
  export type UserInviteUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * The data needed to update a UserInvite.
     */
    data: XOR<UserInviteUpdateInput, UserInviteUncheckedUpdateInput>
    /**
     * Choose, which UserInvite to update.
     */
    where: UserInviteWhereUniqueInput
  }

  /**
   * UserInvite updateMany
   */
  export type UserInviteUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UserInvites.
     */
    data: XOR<UserInviteUpdateManyMutationInput, UserInviteUncheckedUpdateManyInput>
    /**
     * Filter which UserInvites to update
     */
    where?: UserInviteWhereInput
    /**
     * Limit how many UserInvites to update.
     */
    limit?: number
  }

  /**
   * UserInvite updateManyAndReturn
   */
  export type UserInviteUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * The data used to update UserInvites.
     */
    data: XOR<UserInviteUpdateManyMutationInput, UserInviteUncheckedUpdateManyInput>
    /**
     * Filter which UserInvites to update
     */
    where?: UserInviteWhereInput
    /**
     * Limit how many UserInvites to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * UserInvite upsert
   */
  export type UserInviteUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * The filter to search for the UserInvite to update in case it exists.
     */
    where: UserInviteWhereUniqueInput
    /**
     * In case the UserInvite found by the `where` argument doesn't exist, create a new UserInvite with this data.
     */
    create: XOR<UserInviteCreateInput, UserInviteUncheckedCreateInput>
    /**
     * In case the UserInvite was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserInviteUpdateInput, UserInviteUncheckedUpdateInput>
  }

  /**
   * UserInvite delete
   */
  export type UserInviteDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserInvite
     */
    select?: UserInviteSelect<ExtArgs> | null
    /**
     * Omit specific fields from the UserInvite
     */
    omit?: UserInviteOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInviteInclude<ExtArgs> | null
    /**
     * Filter which UserInvite to delete.
     */
    where: UserInviteWhereUniqueInput
  }

  /**
   * UserInvite deleteMany
   */
  export type UserInviteDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserInvites to delete
     */
    where?: UserInviteWhereInput
    /**
     * Limit how many UserInvites to delete.
     */
    limit?: number
  }

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


  /**
   * Model Account
   */

  export type AggregateAccount = {
    _count: AccountCountAggregateOutputType | null
    _avg: AccountAvgAggregateOutputType | null
    _sum: AccountSumAggregateOutputType | null
    _min: AccountMinAggregateOutputType | null
    _max: AccountMaxAggregateOutputType | null
  }

  export type AccountAvgAggregateOutputType = {
    expires_at: number | null
  }

  export type AccountSumAggregateOutputType = {
    expires_at: number | null
  }

  export type AccountMinAggregateOutputType = {
    id: string | null
    userId: string | null
    type: string | null
    provider: string | null
    providerAccountId: string | null
    password: string | null
    refresh_token: string | null
    access_token: string | null
    expires_at: number | null
    accessTokenExpiresAt: Date | null
    refreshTokenExpiresAt: Date | null
    token_type: string | null
    scope: string | null
    id_token: string | null
    session_state: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AccountMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    type: string | null
    provider: string | null
    providerAccountId: string | null
    password: string | null
    refresh_token: string | null
    access_token: string | null
    expires_at: number | null
    accessTokenExpiresAt: Date | null
    refreshTokenExpiresAt: Date | null
    token_type: string | null
    scope: string | null
    id_token: string | null
    session_state: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AccountCountAggregateOutputType = {
    id: number
    userId: number
    type: number
    provider: number
    providerAccountId: number
    password: number
    refresh_token: number
    access_token: number
    expires_at: number
    accessTokenExpiresAt: number
    refreshTokenExpiresAt: number
    token_type: number
    scope: number
    id_token: number
    session_state: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type AccountAvgAggregateInputType = {
    expires_at?: true
  }

  export type AccountSumAggregateInputType = {
    expires_at?: true
  }

  export type AccountMinAggregateInputType = {
    id?: true
    userId?: true
    type?: true
    provider?: true
    providerAccountId?: true
    password?: true
    refresh_token?: true
    access_token?: true
    expires_at?: true
    accessTokenExpiresAt?: true
    refreshTokenExpiresAt?: true
    token_type?: true
    scope?: true
    id_token?: true
    session_state?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AccountMaxAggregateInputType = {
    id?: true
    userId?: true
    type?: true
    provider?: true
    providerAccountId?: true
    password?: true
    refresh_token?: true
    access_token?: true
    expires_at?: true
    accessTokenExpiresAt?: true
    refreshTokenExpiresAt?: true
    token_type?: true
    scope?: true
    id_token?: true
    session_state?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AccountCountAggregateInputType = {
    id?: true
    userId?: true
    type?: true
    provider?: true
    providerAccountId?: true
    password?: true
    refresh_token?: true
    access_token?: true
    expires_at?: true
    accessTokenExpiresAt?: true
    refreshTokenExpiresAt?: true
    token_type?: true
    scope?: true
    id_token?: true
    session_state?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type AccountAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Account to aggregate.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Accounts
    **/
    _count?: true | AccountCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AccountAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AccountSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AccountMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AccountMaxAggregateInputType
  }

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




  export type AccountGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithAggregationInput | AccountOrderByWithAggregationInput[]
    by: AccountScalarFieldEnum[] | AccountScalarFieldEnum
    having?: AccountScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AccountCountAggregateInputType | true
    _avg?: AccountAvgAggregateInputType
    _sum?: AccountSumAggregateInputType
    _min?: AccountMinAggregateInputType
    _max?: AccountMaxAggregateInputType
  }

  export type AccountGroupByOutputType = {
    id: string
    userId: string
    type: string
    provider: string
    providerAccountId: string
    password: string | null
    refresh_token: string | null
    access_token: string | null
    expires_at: number | null
    accessTokenExpiresAt: Date | null
    refreshTokenExpiresAt: Date | null
    token_type: string | null
    scope: string | null
    id_token: string | null
    session_state: string | null
    createdAt: Date
    updatedAt: Date
    _count: AccountCountAggregateOutputType | null
    _avg: AccountAvgAggregateOutputType | null
    _sum: AccountSumAggregateOutputType | null
    _min: AccountMinAggregateOutputType | null
    _max: AccountMaxAggregateOutputType | null
  }

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


  export type AccountSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    type?: boolean
    provider?: boolean
    providerAccountId?: boolean
    password?: boolean
    refresh_token?: boolean
    access_token?: boolean
    expires_at?: boolean
    accessTokenExpiresAt?: boolean
    refreshTokenExpiresAt?: boolean
    token_type?: boolean
    scope?: boolean
    id_token?: boolean
    session_state?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>

  export type AccountSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    type?: boolean
    provider?: boolean
    providerAccountId?: boolean
    password?: boolean
    refresh_token?: boolean
    access_token?: boolean
    expires_at?: boolean
    accessTokenExpiresAt?: boolean
    refreshTokenExpiresAt?: boolean
    token_type?: boolean
    scope?: boolean
    id_token?: boolean
    session_state?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>

  export type AccountSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    type?: boolean
    provider?: boolean
    providerAccountId?: boolean
    password?: boolean
    refresh_token?: boolean
    access_token?: boolean
    expires_at?: boolean
    accessTokenExpiresAt?: boolean
    refreshTokenExpiresAt?: boolean
    token_type?: boolean
    scope?: boolean
    id_token?: boolean
    session_state?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>

  export type AccountSelectScalar = {
    id?: boolean
    userId?: boolean
    type?: boolean
    provider?: boolean
    providerAccountId?: boolean
    password?: boolean
    refresh_token?: boolean
    access_token?: boolean
    expires_at?: boolean
    accessTokenExpiresAt?: boolean
    refreshTokenExpiresAt?: boolean
    token_type?: boolean
    scope?: boolean
    id_token?: boolean
    session_state?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type AccountOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "type" | "provider" | "providerAccountId" | "password" | "refresh_token" | "access_token" | "expires_at" | "accessTokenExpiresAt" | "refreshTokenExpiresAt" | "token_type" | "scope" | "id_token" | "session_state" | "createdAt" | "updatedAt", ExtArgs["result"]["account"]>
  export type AccountInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AccountIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AccountIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AccountPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Account"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      /**
       * Legacy Auth.js discriminator; Better Auth omits it on create — default keeps OAuth/credential rows valid.
       */
      type: string
      provider: string
      providerAccountId: string
      /**
       * Better Auth email/password (credential provider) hash; kept in sync with `User.passwordHash` for local flows.
       */
      password: string | null
      refresh_token: string | null
      access_token: string | null
      /**
       * Legacy Auth.js unix seconds expiry; retained for existing rows only.
       */
      expires_at: number | null
      accessTokenExpiresAt: Date | null
      refreshTokenExpiresAt: Date | null
      token_type: string | null
      scope: string | null
      id_token: string | null
      session_state: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["account"]>
    composites: {}
  }

  type AccountGetPayload<S extends boolean | null | undefined | AccountDefaultArgs> = $Result.GetResult<Prisma.$AccountPayload, S>

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

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

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

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

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

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

    /**
     * Create a Account.
     * @param {AccountCreateArgs} args - Arguments to create a Account.
     * @example
     * // Create one Account
     * const Account = await prisma.account.create({
     *   data: {
     *     // ... data to create a Account
     *   }
     * })
     * 
     */
    create<T extends AccountCreateArgs>(args: SelectSubset<T, AccountCreateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Accounts and returns the data saved in the database.
     * @param {AccountCreateManyAndReturnArgs} args - Arguments to create many Accounts.
     * @example
     * // Create many Accounts
     * const account = await prisma.account.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Accounts and only return the `id`
     * const accountWithIdOnly = await prisma.account.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 AccountCreateManyAndReturnArgs>(args?: SelectSubset<T, AccountCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Account.
     * @param {AccountDeleteArgs} args - Arguments to delete one Account.
     * @example
     * // Delete one Account
     * const Account = await prisma.account.delete({
     *   where: {
     *     // ... filter to delete one Account
     *   }
     * })
     * 
     */
    delete<T extends AccountDeleteArgs>(args: SelectSubset<T, AccountDeleteArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the Account model
   */
  interface AccountFieldRefs {
    readonly id: FieldRef<"Account", 'String'>
    readonly userId: FieldRef<"Account", 'String'>
    readonly type: FieldRef<"Account", 'String'>
    readonly provider: FieldRef<"Account", 'String'>
    readonly providerAccountId: FieldRef<"Account", 'String'>
    readonly password: FieldRef<"Account", 'String'>
    readonly refresh_token: FieldRef<"Account", 'String'>
    readonly access_token: FieldRef<"Account", 'String'>
    readonly expires_at: FieldRef<"Account", 'Int'>
    readonly accessTokenExpiresAt: FieldRef<"Account", 'DateTime'>
    readonly refreshTokenExpiresAt: FieldRef<"Account", 'DateTime'>
    readonly token_type: FieldRef<"Account", 'String'>
    readonly scope: FieldRef<"Account", 'String'>
    readonly id_token: FieldRef<"Account", 'String'>
    readonly session_state: FieldRef<"Account", 'String'>
    readonly createdAt: FieldRef<"Account", 'DateTime'>
    readonly updatedAt: FieldRef<"Account", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Account findUnique
   */
  export type AccountFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account findUniqueOrThrow
   */
  export type AccountFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where: AccountWhereUniqueInput
  }

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

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

  /**
   * Account findMany
   */
  export type AccountFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Accounts to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accounts.
     */
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account create
   */
  export type AccountCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The data needed to create a Account.
     */
    data: XOR<AccountCreateInput, AccountUncheckedCreateInput>
  }

  /**
   * Account createMany
   */
  export type AccountCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Accounts.
     */
    data: AccountCreateManyInput | AccountCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Account createManyAndReturn
   */
  export type AccountCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * The data used to create many Accounts.
     */
    data: AccountCreateManyInput | AccountCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Account update
   */
  export type AccountUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The data needed to update a Account.
     */
    data: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
    /**
     * Choose, which Account to update.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account updateMany
   */
  export type AccountUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Accounts.
     */
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
    /**
     * Filter which Accounts to update
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to update.
     */
    limit?: number
  }

  /**
   * Account updateManyAndReturn
   */
  export type AccountUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * The data used to update Accounts.
     */
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
    /**
     * Filter which Accounts to update
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Account upsert
   */
  export type AccountUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The filter to search for the Account to update in case it exists.
     */
    where: AccountWhereUniqueInput
    /**
     * In case the Account found by the `where` argument doesn't exist, create a new Account with this data.
     */
    create: XOR<AccountCreateInput, AccountUncheckedCreateInput>
    /**
     * In case the Account was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
  }

  /**
   * Account delete
   */
  export type AccountDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter which Account to delete.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account deleteMany
   */
  export type AccountDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Accounts to delete
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to delete.
     */
    limit?: number
  }

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


  /**
   * Model Session
   */

  export type AggregateSession = {
    _count: SessionCountAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  export type SessionMinAggregateOutputType = {
    id: string | null
    sessionToken: string | null
    userId: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
    ipAddress: string | null
    userAgent: string | null
  }

  export type SessionMaxAggregateOutputType = {
    id: string | null
    sessionToken: string | null
    userId: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
    ipAddress: string | null
    userAgent: string | null
  }

  export type SessionCountAggregateOutputType = {
    id: number
    sessionToken: number
    userId: number
    expires: number
    createdAt: number
    updatedAt: number
    ipAddress: number
    userAgent: number
    _all: number
  }


  export type SessionMinAggregateInputType = {
    id?: true
    sessionToken?: true
    userId?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    ipAddress?: true
    userAgent?: true
  }

  export type SessionMaxAggregateInputType = {
    id?: true
    sessionToken?: true
    userId?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    ipAddress?: true
    userAgent?: true
  }

  export type SessionCountAggregateInputType = {
    id?: true
    sessionToken?: true
    userId?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    ipAddress?: true
    userAgent?: true
    _all?: true
  }

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

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




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

  export type SessionGroupByOutputType = {
    id: string
    sessionToken: string
    userId: string
    expires: Date
    createdAt: Date
    updatedAt: Date
    ipAddress: string | null
    userAgent: string | null
    _count: SessionCountAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

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


  export type SessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectScalar = {
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    ipAddress?: boolean
    userAgent?: boolean
  }

  export type SessionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "sessionToken" | "userId" | "expires" | "createdAt" | "updatedAt" | "ipAddress" | "userAgent", ExtArgs["result"]["session"]>
  export type SessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SessionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $SessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Session"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      sessionToken: string
      userId: string
      expires: Date
      createdAt: Date
      updatedAt: Date
      ipAddress: string | null
      userAgent: 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' | 'omit'> & {
      select?: SessionCountAggregateInputType | true
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Session.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__SessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Session model
   */
  interface SessionFieldRefs {
    readonly id: FieldRef<"Session", 'String'>
    readonly sessionToken: FieldRef<"Session", 'String'>
    readonly userId: FieldRef<"Session", 'String'>
    readonly expires: FieldRef<"Session", 'DateTime'>
    readonly createdAt: FieldRef<"Session", 'DateTime'>
    readonly updatedAt: FieldRef<"Session", 'DateTime'>
    readonly ipAddress: FieldRef<"Session", 'String'>
    readonly userAgent: 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
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

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

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

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

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

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

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

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

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

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

  /**
   * Session updateManyAndReturn
   */
  export type SessionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * The data used to update Sessions.
     */
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
    /**
     * Filter which Sessions to update
     */
    where?: SessionWhereInput
    /**
     * Limit how many Sessions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

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

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

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

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


  /**
   * Model VerificationToken
   */

  export type AggregateVerificationToken = {
    _count: VerificationTokenCountAggregateOutputType | null
    _min: VerificationTokenMinAggregateOutputType | null
    _max: VerificationTokenMaxAggregateOutputType | null
  }

  export type VerificationTokenMinAggregateOutputType = {
    id: string | null
    identifier: string | null
    token: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type VerificationTokenMaxAggregateOutputType = {
    id: string | null
    identifier: string | null
    token: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type VerificationTokenCountAggregateOutputType = {
    id: number
    identifier: number
    token: number
    expires: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type VerificationTokenMinAggregateInputType = {
    id?: true
    identifier?: true
    token?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
  }

  export type VerificationTokenMaxAggregateInputType = {
    id?: true
    identifier?: true
    token?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
  }

  export type VerificationTokenCountAggregateInputType = {
    id?: true
    identifier?: true
    token?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type VerificationTokenGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VerificationTokenWhereInput
    orderBy?: VerificationTokenOrderByWithAggregationInput | VerificationTokenOrderByWithAggregationInput[]
    by: VerificationTokenScalarFieldEnum[] | VerificationTokenScalarFieldEnum
    having?: VerificationTokenScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VerificationTokenCountAggregateInputType | true
    _min?: VerificationTokenMinAggregateInputType
    _max?: VerificationTokenMaxAggregateInputType
  }

  export type VerificationTokenGroupByOutputType = {
    id: string
    identifier: string
    token: string
    expires: Date
    createdAt: Date
    updatedAt: Date
    _count: VerificationTokenCountAggregateOutputType | null
    _min: VerificationTokenMinAggregateOutputType | null
    _max: VerificationTokenMaxAggregateOutputType | null
  }

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


  export type VerificationTokenSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    identifier?: boolean
    token?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["verificationToken"]>

  export type VerificationTokenSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    identifier?: boolean
    token?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["verificationToken"]>

  export type VerificationTokenSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    identifier?: boolean
    token?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["verificationToken"]>

  export type VerificationTokenSelectScalar = {
    id?: boolean
    identifier?: boolean
    token?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type VerificationTokenOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "identifier" | "token" | "expires" | "createdAt" | "updatedAt", ExtArgs["result"]["verificationToken"]>

  export type $VerificationTokenPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "VerificationToken"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      identifier: string
      token: string
      expires: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["verificationToken"]>
    composites: {}
  }

  type VerificationTokenGetPayload<S extends boolean | null | undefined | VerificationTokenDefaultArgs> = $Result.GetResult<Prisma.$VerificationTokenPayload, S>

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

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

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

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

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

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

    /**
     * Create a VerificationToken.
     * @param {VerificationTokenCreateArgs} args - Arguments to create a VerificationToken.
     * @example
     * // Create one VerificationToken
     * const VerificationToken = await prisma.verificationToken.create({
     *   data: {
     *     // ... data to create a VerificationToken
     *   }
     * })
     * 
     */
    create<T extends VerificationTokenCreateArgs>(args: SelectSubset<T, VerificationTokenCreateArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many VerificationTokens and returns the data saved in the database.
     * @param {VerificationTokenCreateManyAndReturnArgs} args - Arguments to create many VerificationTokens.
     * @example
     * // Create many VerificationTokens
     * const verificationToken = await prisma.verificationToken.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many VerificationTokens and only return the `id`
     * const verificationTokenWithIdOnly = await prisma.verificationToken.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 VerificationTokenCreateManyAndReturnArgs>(args?: SelectSubset<T, VerificationTokenCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a VerificationToken.
     * @param {VerificationTokenDeleteArgs} args - Arguments to delete one VerificationToken.
     * @example
     * // Delete one VerificationToken
     * const VerificationToken = await prisma.verificationToken.delete({
     *   where: {
     *     // ... filter to delete one VerificationToken
     *   }
     * })
     * 
     */
    delete<T extends VerificationTokenDeleteArgs>(args: SelectSubset<T, VerificationTokenDeleteArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the VerificationToken model
   */
  interface VerificationTokenFieldRefs {
    readonly id: FieldRef<"VerificationToken", 'String'>
    readonly identifier: FieldRef<"VerificationToken", 'String'>
    readonly token: FieldRef<"VerificationToken", 'String'>
    readonly expires: FieldRef<"VerificationToken", 'DateTime'>
    readonly createdAt: FieldRef<"VerificationToken", 'DateTime'>
    readonly updatedAt: FieldRef<"VerificationToken", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * VerificationToken findUnique
   */
  export type VerificationTokenFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * Filter, which VerificationToken to fetch.
     */
    where: VerificationTokenWhereUniqueInput
  }

  /**
   * VerificationToken findUniqueOrThrow
   */
  export type VerificationTokenFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * Filter, which VerificationToken to fetch.
     */
    where: VerificationTokenWhereUniqueInput
  }

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

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

  /**
   * VerificationToken findMany
   */
  export type VerificationTokenFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * Filter, which VerificationTokens to fetch.
     */
    where?: VerificationTokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of VerificationTokens to fetch.
     */
    orderBy?: VerificationTokenOrderByWithRelationInput | VerificationTokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing VerificationTokens.
     */
    cursor?: VerificationTokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` VerificationTokens 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` VerificationTokens.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of VerificationTokens.
     */
    distinct?: VerificationTokenScalarFieldEnum | VerificationTokenScalarFieldEnum[]
  }

  /**
   * VerificationToken create
   */
  export type VerificationTokenCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * The data needed to create a VerificationToken.
     */
    data: XOR<VerificationTokenCreateInput, VerificationTokenUncheckedCreateInput>
  }

  /**
   * VerificationToken createMany
   */
  export type VerificationTokenCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many VerificationTokens.
     */
    data: VerificationTokenCreateManyInput | VerificationTokenCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * VerificationToken createManyAndReturn
   */
  export type VerificationTokenCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * The data used to create many VerificationTokens.
     */
    data: VerificationTokenCreateManyInput | VerificationTokenCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * VerificationToken update
   */
  export type VerificationTokenUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * The data needed to update a VerificationToken.
     */
    data: XOR<VerificationTokenUpdateInput, VerificationTokenUncheckedUpdateInput>
    /**
     * Choose, which VerificationToken to update.
     */
    where: VerificationTokenWhereUniqueInput
  }

  /**
   * VerificationToken updateMany
   */
  export type VerificationTokenUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update VerificationTokens.
     */
    data: XOR<VerificationTokenUpdateManyMutationInput, VerificationTokenUncheckedUpdateManyInput>
    /**
     * Filter which VerificationTokens to update
     */
    where?: VerificationTokenWhereInput
    /**
     * Limit how many VerificationTokens to update.
     */
    limit?: number
  }

  /**
   * VerificationToken updateManyAndReturn
   */
  export type VerificationTokenUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * The data used to update VerificationTokens.
     */
    data: XOR<VerificationTokenUpdateManyMutationInput, VerificationTokenUncheckedUpdateManyInput>
    /**
     * Filter which VerificationTokens to update
     */
    where?: VerificationTokenWhereInput
    /**
     * Limit how many VerificationTokens to update.
     */
    limit?: number
  }

  /**
   * VerificationToken upsert
   */
  export type VerificationTokenUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * The filter to search for the VerificationToken to update in case it exists.
     */
    where: VerificationTokenWhereUniqueInput
    /**
     * In case the VerificationToken found by the `where` argument doesn't exist, create a new VerificationToken with this data.
     */
    create: XOR<VerificationTokenCreateInput, VerificationTokenUncheckedCreateInput>
    /**
     * In case the VerificationToken was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VerificationTokenUpdateInput, VerificationTokenUncheckedUpdateInput>
  }

  /**
   * VerificationToken delete
   */
  export type VerificationTokenDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the VerificationToken
     */
    select?: VerificationTokenSelect<ExtArgs> | null
    /**
     * Omit specific fields from the VerificationToken
     */
    omit?: VerificationTokenOmit<ExtArgs> | null
    /**
     * Filter which VerificationToken to delete.
     */
    where: VerificationTokenWhereUniqueInput
  }

  /**
   * VerificationToken deleteMany
   */
  export type VerificationTokenDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which VerificationTokens to delete
     */
    where?: VerificationTokenWhereInput
    /**
     * Limit how many VerificationTokens to delete.
     */
    limit?: number
  }

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


  /**
   * Model WorkflowAuditLog
   */

  export type AggregateWorkflowAuditLog = {
    _count: WorkflowAuditLogCountAggregateOutputType | null
    _min: WorkflowAuditLogMinAggregateOutputType | null
    _max: WorkflowAuditLogMaxAggregateOutputType | null
  }

  export type WorkflowAuditLogMinAggregateOutputType = {
    id: string | null
    occurredAt: Date | null
    actorUserId: string | null
    actorSessionId: string | null
    action: string | null
    resourceType: string | null
    resourceId: string | null
    outcome: string | null
    errorCode: string | null
    correlationId: string | null
    workflowId: string | null
    runId: string | null
    nodeId: string | null
  }

  export type WorkflowAuditLogMaxAggregateOutputType = {
    id: string | null
    occurredAt: Date | null
    actorUserId: string | null
    actorSessionId: string | null
    action: string | null
    resourceType: string | null
    resourceId: string | null
    outcome: string | null
    errorCode: string | null
    correlationId: string | null
    workflowId: string | null
    runId: string | null
    nodeId: string | null
  }

  export type WorkflowAuditLogCountAggregateOutputType = {
    id: number
    occurredAt: number
    actorUserId: number
    actorSessionId: number
    action: number
    resourceType: number
    resourceId: number
    outcome: number
    errorCode: number
    correlationId: number
    workflowId: number
    runId: number
    nodeId: number
    _all: number
  }


  export type WorkflowAuditLogMinAggregateInputType = {
    id?: true
    occurredAt?: true
    actorUserId?: true
    actorSessionId?: true
    action?: true
    resourceType?: true
    resourceId?: true
    outcome?: true
    errorCode?: true
    correlationId?: true
    workflowId?: true
    runId?: true
    nodeId?: true
  }

  export type WorkflowAuditLogMaxAggregateInputType = {
    id?: true
    occurredAt?: true
    actorUserId?: true
    actorSessionId?: true
    action?: true
    resourceType?: true
    resourceId?: true
    outcome?: true
    errorCode?: true
    correlationId?: true
    workflowId?: true
    runId?: true
    nodeId?: true
  }

  export type WorkflowAuditLogCountAggregateInputType = {
    id?: true
    occurredAt?: true
    actorUserId?: true
    actorSessionId?: true
    action?: true
    resourceType?: true
    resourceId?: true
    outcome?: true
    errorCode?: true
    correlationId?: true
    workflowId?: true
    runId?: true
    nodeId?: true
    _all?: true
  }

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

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




  export type WorkflowAuditLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WorkflowAuditLogWhereInput
    orderBy?: WorkflowAuditLogOrderByWithAggregationInput | WorkflowAuditLogOrderByWithAggregationInput[]
    by: WorkflowAuditLogScalarFieldEnum[] | WorkflowAuditLogScalarFieldEnum
    having?: WorkflowAuditLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WorkflowAuditLogCountAggregateInputType | true
    _min?: WorkflowAuditLogMinAggregateInputType
    _max?: WorkflowAuditLogMaxAggregateInputType
  }

  export type WorkflowAuditLogGroupByOutputType = {
    id: string
    occurredAt: Date
    actorUserId: string | null
    actorSessionId: string | null
    action: string
    resourceType: string
    resourceId: string
    outcome: string
    errorCode: string | null
    correlationId: string | null
    workflowId: string
    runId: string | null
    nodeId: string | null
    _count: WorkflowAuditLogCountAggregateOutputType | null
    _min: WorkflowAuditLogMinAggregateOutputType | null
    _max: WorkflowAuditLogMaxAggregateOutputType | null
  }

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


  export type WorkflowAuditLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    occurredAt?: boolean
    actorUserId?: boolean
    actorSessionId?: boolean
    action?: boolean
    resourceType?: boolean
    resourceId?: boolean
    outcome?: boolean
    errorCode?: boolean
    correlationId?: boolean
    workflowId?: boolean
    runId?: boolean
    nodeId?: boolean
  }, ExtArgs["result"]["workflowAuditLog"]>

  export type WorkflowAuditLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    occurredAt?: boolean
    actorUserId?: boolean
    actorSessionId?: boolean
    action?: boolean
    resourceType?: boolean
    resourceId?: boolean
    outcome?: boolean
    errorCode?: boolean
    correlationId?: boolean
    workflowId?: boolean
    runId?: boolean
    nodeId?: boolean
  }, ExtArgs["result"]["workflowAuditLog"]>

  export type WorkflowAuditLogSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    occurredAt?: boolean
    actorUserId?: boolean
    actorSessionId?: boolean
    action?: boolean
    resourceType?: boolean
    resourceId?: boolean
    outcome?: boolean
    errorCode?: boolean
    correlationId?: boolean
    workflowId?: boolean
    runId?: boolean
    nodeId?: boolean
  }, ExtArgs["result"]["workflowAuditLog"]>

  export type WorkflowAuditLogSelectScalar = {
    id?: boolean
    occurredAt?: boolean
    actorUserId?: boolean
    actorSessionId?: boolean
    action?: boolean
    resourceType?: boolean
    resourceId?: boolean
    outcome?: boolean
    errorCode?: boolean
    correlationId?: boolean
    workflowId?: boolean
    runId?: boolean
    nodeId?: boolean
  }

  export type WorkflowAuditLogOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "occurredAt" | "actorUserId" | "actorSessionId" | "action" | "resourceType" | "resourceId" | "outcome" | "errorCode" | "correlationId" | "workflowId" | "runId" | "nodeId", ExtArgs["result"]["workflowAuditLog"]>

  export type $WorkflowAuditLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WorkflowAuditLog"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      occurredAt: Date
      actorUserId: string | null
      actorSessionId: string | null
      action: string
      resourceType: string
      resourceId: string
      outcome: string
      errorCode: string | null
      correlationId: string | null
      workflowId: string
      runId: string | null
      nodeId: string | null
    }, ExtArgs["result"]["workflowAuditLog"]>
    composites: {}
  }

  type WorkflowAuditLogGetPayload<S extends boolean | null | undefined | WorkflowAuditLogDefaultArgs> = $Result.GetResult<Prisma.$WorkflowAuditLogPayload, S>

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

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

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

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

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

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

    /**
     * Create a WorkflowAuditLog.
     * @param {WorkflowAuditLogCreateArgs} args - Arguments to create a WorkflowAuditLog.
     * @example
     * // Create one WorkflowAuditLog
     * const WorkflowAuditLog = await prisma.workflowAuditLog.create({
     *   data: {
     *     // ... data to create a WorkflowAuditLog
     *   }
     * })
     * 
     */
    create<T extends WorkflowAuditLogCreateArgs>(args: SelectSubset<T, WorkflowAuditLogCreateArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many WorkflowAuditLogs and returns the data saved in the database.
     * @param {WorkflowAuditLogCreateManyAndReturnArgs} args - Arguments to create many WorkflowAuditLogs.
     * @example
     * // Create many WorkflowAuditLogs
     * const workflowAuditLog = await prisma.workflowAuditLog.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many WorkflowAuditLogs and only return the `id`
     * const workflowAuditLogWithIdOnly = await prisma.workflowAuditLog.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 WorkflowAuditLogCreateManyAndReturnArgs>(args?: SelectSubset<T, WorkflowAuditLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a WorkflowAuditLog.
     * @param {WorkflowAuditLogDeleteArgs} args - Arguments to delete one WorkflowAuditLog.
     * @example
     * // Delete one WorkflowAuditLog
     * const WorkflowAuditLog = await prisma.workflowAuditLog.delete({
     *   where: {
     *     // ... filter to delete one WorkflowAuditLog
     *   }
     * })
     * 
     */
    delete<T extends WorkflowAuditLogDeleteArgs>(args: SelectSubset<T, WorkflowAuditLogDeleteArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the WorkflowAuditLog model
   */
  interface WorkflowAuditLogFieldRefs {
    readonly id: FieldRef<"WorkflowAuditLog", 'String'>
    readonly occurredAt: FieldRef<"WorkflowAuditLog", 'DateTime'>
    readonly actorUserId: FieldRef<"WorkflowAuditLog", 'String'>
    readonly actorSessionId: FieldRef<"WorkflowAuditLog", 'String'>
    readonly action: FieldRef<"WorkflowAuditLog", 'String'>
    readonly resourceType: FieldRef<"WorkflowAuditLog", 'String'>
    readonly resourceId: FieldRef<"WorkflowAuditLog", 'String'>
    readonly outcome: FieldRef<"WorkflowAuditLog", 'String'>
    readonly errorCode: FieldRef<"WorkflowAuditLog", 'String'>
    readonly correlationId: FieldRef<"WorkflowAuditLog", 'String'>
    readonly workflowId: FieldRef<"WorkflowAuditLog", 'String'>
    readonly runId: FieldRef<"WorkflowAuditLog", 'String'>
    readonly nodeId: FieldRef<"WorkflowAuditLog", 'String'>
  }
    

  // Custom InputTypes
  /**
   * WorkflowAuditLog findUnique
   */
  export type WorkflowAuditLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowAuditLog to fetch.
     */
    where: WorkflowAuditLogWhereUniqueInput
  }

  /**
   * WorkflowAuditLog findUniqueOrThrow
   */
  export type WorkflowAuditLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowAuditLog to fetch.
     */
    where: WorkflowAuditLogWhereUniqueInput
  }

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

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

  /**
   * WorkflowAuditLog findMany
   */
  export type WorkflowAuditLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * Filter, which WorkflowAuditLogs to fetch.
     */
    where?: WorkflowAuditLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WorkflowAuditLogs to fetch.
     */
    orderBy?: WorkflowAuditLogOrderByWithRelationInput | WorkflowAuditLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WorkflowAuditLogs.
     */
    cursor?: WorkflowAuditLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WorkflowAuditLogs 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` WorkflowAuditLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of WorkflowAuditLogs.
     */
    distinct?: WorkflowAuditLogScalarFieldEnum | WorkflowAuditLogScalarFieldEnum[]
  }

  /**
   * WorkflowAuditLog create
   */
  export type WorkflowAuditLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * The data needed to create a WorkflowAuditLog.
     */
    data: XOR<WorkflowAuditLogCreateInput, WorkflowAuditLogUncheckedCreateInput>
  }

  /**
   * WorkflowAuditLog createMany
   */
  export type WorkflowAuditLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many WorkflowAuditLogs.
     */
    data: WorkflowAuditLogCreateManyInput | WorkflowAuditLogCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowAuditLog createManyAndReturn
   */
  export type WorkflowAuditLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * The data used to create many WorkflowAuditLogs.
     */
    data: WorkflowAuditLogCreateManyInput | WorkflowAuditLogCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * WorkflowAuditLog update
   */
  export type WorkflowAuditLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * The data needed to update a WorkflowAuditLog.
     */
    data: XOR<WorkflowAuditLogUpdateInput, WorkflowAuditLogUncheckedUpdateInput>
    /**
     * Choose, which WorkflowAuditLog to update.
     */
    where: WorkflowAuditLogWhereUniqueInput
  }

  /**
   * WorkflowAuditLog updateMany
   */
  export type WorkflowAuditLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WorkflowAuditLogs.
     */
    data: XOR<WorkflowAuditLogUpdateManyMutationInput, WorkflowAuditLogUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowAuditLogs to update
     */
    where?: WorkflowAuditLogWhereInput
    /**
     * Limit how many WorkflowAuditLogs to update.
     */
    limit?: number
  }

  /**
   * WorkflowAuditLog updateManyAndReturn
   */
  export type WorkflowAuditLogUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * The data used to update WorkflowAuditLogs.
     */
    data: XOR<WorkflowAuditLogUpdateManyMutationInput, WorkflowAuditLogUncheckedUpdateManyInput>
    /**
     * Filter which WorkflowAuditLogs to update
     */
    where?: WorkflowAuditLogWhereInput
    /**
     * Limit how many WorkflowAuditLogs to update.
     */
    limit?: number
  }

  /**
   * WorkflowAuditLog upsert
   */
  export type WorkflowAuditLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * The filter to search for the WorkflowAuditLog to update in case it exists.
     */
    where: WorkflowAuditLogWhereUniqueInput
    /**
     * In case the WorkflowAuditLog found by the `where` argument doesn't exist, create a new WorkflowAuditLog with this data.
     */
    create: XOR<WorkflowAuditLogCreateInput, WorkflowAuditLogUncheckedCreateInput>
    /**
     * In case the WorkflowAuditLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WorkflowAuditLogUpdateInput, WorkflowAuditLogUncheckedUpdateInput>
  }

  /**
   * WorkflowAuditLog delete
   */
  export type WorkflowAuditLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WorkflowAuditLog
     */
    select?: WorkflowAuditLogSelect<ExtArgs> | null
    /**
     * Omit specific fields from the WorkflowAuditLog
     */
    omit?: WorkflowAuditLogOmit<ExtArgs> | null
    /**
     * Filter which WorkflowAuditLog to delete.
     */
    where: WorkflowAuditLogWhereUniqueInput
  }

  /**
   * WorkflowAuditLog deleteMany
   */
  export type WorkflowAuditLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WorkflowAuditLogs to delete
     */
    where?: WorkflowAuditLogWhereInput
    /**
     * Limit how many WorkflowAuditLogs to delete.
     */
    limit?: number
  }

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


  /**
   * Model HmacNonce
   */

  export type AggregateHmacNonce = {
    _count: HmacNonceCountAggregateOutputType | null
    _min: HmacNonceMinAggregateOutputType | null
    _max: HmacNonceMaxAggregateOutputType | null
  }

  export type HmacNonceMinAggregateOutputType = {
    nonce: string | null
    expiresAt: Date | null
  }

  export type HmacNonceMaxAggregateOutputType = {
    nonce: string | null
    expiresAt: Date | null
  }

  export type HmacNonceCountAggregateOutputType = {
    nonce: number
    expiresAt: number
    _all: number
  }


  export type HmacNonceMinAggregateInputType = {
    nonce?: true
    expiresAt?: true
  }

  export type HmacNonceMaxAggregateInputType = {
    nonce?: true
    expiresAt?: true
  }

  export type HmacNonceCountAggregateInputType = {
    nonce?: true
    expiresAt?: true
    _all?: true
  }

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

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




  export type HmacNonceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HmacNonceWhereInput
    orderBy?: HmacNonceOrderByWithAggregationInput | HmacNonceOrderByWithAggregationInput[]
    by: HmacNonceScalarFieldEnum[] | HmacNonceScalarFieldEnum
    having?: HmacNonceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HmacNonceCountAggregateInputType | true
    _min?: HmacNonceMinAggregateInputType
    _max?: HmacNonceMaxAggregateInputType
  }

  export type HmacNonceGroupByOutputType = {
    nonce: string
    expiresAt: Date
    _count: HmacNonceCountAggregateOutputType | null
    _min: HmacNonceMinAggregateOutputType | null
    _max: HmacNonceMaxAggregateOutputType | null
  }

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


  export type HmacNonceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    nonce?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["hmacNonce"]>

  export type HmacNonceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    nonce?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["hmacNonce"]>

  export type HmacNonceSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    nonce?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["hmacNonce"]>

  export type HmacNonceSelectScalar = {
    nonce?: boolean
    expiresAt?: boolean
  }

  export type HmacNonceOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"nonce" | "expiresAt", ExtArgs["result"]["hmacNonce"]>

  export type $HmacNoncePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "HmacNonce"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      nonce: string
      expiresAt: Date
    }, ExtArgs["result"]["hmacNonce"]>
    composites: {}
  }

  type HmacNonceGetPayload<S extends boolean | null | undefined | HmacNonceDefaultArgs> = $Result.GetResult<Prisma.$HmacNoncePayload, S>

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

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

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

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

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

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

    /**
     * Create a HmacNonce.
     * @param {HmacNonceCreateArgs} args - Arguments to create a HmacNonce.
     * @example
     * // Create one HmacNonce
     * const HmacNonce = await prisma.hmacNonce.create({
     *   data: {
     *     // ... data to create a HmacNonce
     *   }
     * })
     * 
     */
    create<T extends HmacNonceCreateArgs>(args: SelectSubset<T, HmacNonceCreateArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many HmacNonces and returns the data saved in the database.
     * @param {HmacNonceCreateManyAndReturnArgs} args - Arguments to create many HmacNonces.
     * @example
     * // Create many HmacNonces
     * const hmacNonce = await prisma.hmacNonce.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many HmacNonces and only return the `nonce`
     * const hmacNonceWithNonceOnly = await prisma.hmacNonce.createManyAndReturn({
     *   select: { nonce: 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 HmacNonceCreateManyAndReturnArgs>(args?: SelectSubset<T, HmacNonceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a HmacNonce.
     * @param {HmacNonceDeleteArgs} args - Arguments to delete one HmacNonce.
     * @example
     * // Delete one HmacNonce
     * const HmacNonce = await prisma.hmacNonce.delete({
     *   where: {
     *     // ... filter to delete one HmacNonce
     *   }
     * })
     * 
     */
    delete<T extends HmacNonceDeleteArgs>(args: SelectSubset<T, HmacNonceDeleteArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the HmacNonce model
   */
  interface HmacNonceFieldRefs {
    readonly nonce: FieldRef<"HmacNonce", 'String'>
    readonly expiresAt: FieldRef<"HmacNonce", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * HmacNonce findUnique
   */
  export type HmacNonceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * Filter, which HmacNonce to fetch.
     */
    where: HmacNonceWhereUniqueInput
  }

  /**
   * HmacNonce findUniqueOrThrow
   */
  export type HmacNonceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * Filter, which HmacNonce to fetch.
     */
    where: HmacNonceWhereUniqueInput
  }

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

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

  /**
   * HmacNonce findMany
   */
  export type HmacNonceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * Filter, which HmacNonces to fetch.
     */
    where?: HmacNonceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of HmacNonces to fetch.
     */
    orderBy?: HmacNonceOrderByWithRelationInput | HmacNonceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing HmacNonces.
     */
    cursor?: HmacNonceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` HmacNonces 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` HmacNonces.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of HmacNonces.
     */
    distinct?: HmacNonceScalarFieldEnum | HmacNonceScalarFieldEnum[]
  }

  /**
   * HmacNonce create
   */
  export type HmacNonceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * The data needed to create a HmacNonce.
     */
    data: XOR<HmacNonceCreateInput, HmacNonceUncheckedCreateInput>
  }

  /**
   * HmacNonce createMany
   */
  export type HmacNonceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many HmacNonces.
     */
    data: HmacNonceCreateManyInput | HmacNonceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * HmacNonce createManyAndReturn
   */
  export type HmacNonceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * The data used to create many HmacNonces.
     */
    data: HmacNonceCreateManyInput | HmacNonceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * HmacNonce update
   */
  export type HmacNonceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * The data needed to update a HmacNonce.
     */
    data: XOR<HmacNonceUpdateInput, HmacNonceUncheckedUpdateInput>
    /**
     * Choose, which HmacNonce to update.
     */
    where: HmacNonceWhereUniqueInput
  }

  /**
   * HmacNonce updateMany
   */
  export type HmacNonceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update HmacNonces.
     */
    data: XOR<HmacNonceUpdateManyMutationInput, HmacNonceUncheckedUpdateManyInput>
    /**
     * Filter which HmacNonces to update
     */
    where?: HmacNonceWhereInput
    /**
     * Limit how many HmacNonces to update.
     */
    limit?: number
  }

  /**
   * HmacNonce updateManyAndReturn
   */
  export type HmacNonceUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * The data used to update HmacNonces.
     */
    data: XOR<HmacNonceUpdateManyMutationInput, HmacNonceUncheckedUpdateManyInput>
    /**
     * Filter which HmacNonces to update
     */
    where?: HmacNonceWhereInput
    /**
     * Limit how many HmacNonces to update.
     */
    limit?: number
  }

  /**
   * HmacNonce upsert
   */
  export type HmacNonceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * The filter to search for the HmacNonce to update in case it exists.
     */
    where: HmacNonceWhereUniqueInput
    /**
     * In case the HmacNonce found by the `where` argument doesn't exist, create a new HmacNonce with this data.
     */
    create: XOR<HmacNonceCreateInput, HmacNonceUncheckedCreateInput>
    /**
     * In case the HmacNonce was found with the provided `where` argument, update it with this data.
     */
    update: XOR<HmacNonceUpdateInput, HmacNonceUncheckedUpdateInput>
  }

  /**
   * HmacNonce delete
   */
  export type HmacNonceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HmacNonce
     */
    select?: HmacNonceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HmacNonce
     */
    omit?: HmacNonceOmit<ExtArgs> | null
    /**
     * Filter which HmacNonce to delete.
     */
    where: HmacNonceWhereUniqueInput
  }

  /**
   * HmacNonce deleteMany
   */
  export type HmacNonceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HmacNonces to delete
     */
    where?: HmacNonceWhereInput
    /**
     * Limit how many HmacNonces to delete.
     */
    limit?: number
  }

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


  /**
   * Model HumanTask
   */

  export type AggregateHumanTask = {
    _count: HumanTaskCountAggregateOutputType | null
    _avg: HumanTaskAvgAggregateOutputType | null
    _sum: HumanTaskSumAggregateOutputType | null
    _min: HumanTaskMinAggregateOutputType | null
    _max: HumanTaskMaxAggregateOutputType | null
  }

  export type HumanTaskAvgAggregateOutputType = {
    itemIndex: number | null
  }

  export type HumanTaskSumAggregateOutputType = {
    itemIndex: number | null
  }

  export type HumanTaskMinAggregateOutputType = {
    id: string | null
    runId: string | null
    workflowId: string | null
    workspaceId: string | null
    nodeId: string | null
    activationId: string | null
    itemIndex: number | null
    status: string | null
    channel: string | null
    subjectJson: string | null
    metadataJson: string | null
    decisionSchemaJson: string | null
    decisionSchemaHash: string | null
    onTimeout: string | null
    deliveryRefJson: string | null
    decisionJson: string | null
    decidedAt: Date | null
    decidedByJson: string | null
    resumeTokenHash: string | null
    expiresAt: Date | null
    createdAt: Date | null
  }

  export type HumanTaskMaxAggregateOutputType = {
    id: string | null
    runId: string | null
    workflowId: string | null
    workspaceId: string | null
    nodeId: string | null
    activationId: string | null
    itemIndex: number | null
    status: string | null
    channel: string | null
    subjectJson: string | null
    metadataJson: string | null
    decisionSchemaJson: string | null
    decisionSchemaHash: string | null
    onTimeout: string | null
    deliveryRefJson: string | null
    decisionJson: string | null
    decidedAt: Date | null
    decidedByJson: string | null
    resumeTokenHash: string | null
    expiresAt: Date | null
    createdAt: Date | null
  }

  export type HumanTaskCountAggregateOutputType = {
    id: number
    runId: number
    workflowId: number
    workspaceId: number
    nodeId: number
    activationId: number
    itemIndex: number
    status: number
    channel: number
    subjectJson: number
    metadataJson: number
    decisionSchemaJson: number
    decisionSchemaHash: number
    onTimeout: number
    deliveryRefJson: number
    decisionJson: number
    decidedAt: number
    decidedByJson: number
    resumeTokenHash: number
    expiresAt: number
    createdAt: number
    _all: number
  }


  export type HumanTaskAvgAggregateInputType = {
    itemIndex?: true
  }

  export type HumanTaskSumAggregateInputType = {
    itemIndex?: true
  }

  export type HumanTaskMinAggregateInputType = {
    id?: true
    runId?: true
    workflowId?: true
    workspaceId?: true
    nodeId?: true
    activationId?: true
    itemIndex?: true
    status?: true
    channel?: true
    subjectJson?: true
    metadataJson?: true
    decisionSchemaJson?: true
    decisionSchemaHash?: true
    onTimeout?: true
    deliveryRefJson?: true
    decisionJson?: true
    decidedAt?: true
    decidedByJson?: true
    resumeTokenHash?: true
    expiresAt?: true
    createdAt?: true
  }

  export type HumanTaskMaxAggregateInputType = {
    id?: true
    runId?: true
    workflowId?: true
    workspaceId?: true
    nodeId?: true
    activationId?: true
    itemIndex?: true
    status?: true
    channel?: true
    subjectJson?: true
    metadataJson?: true
    decisionSchemaJson?: true
    decisionSchemaHash?: true
    onTimeout?: true
    deliveryRefJson?: true
    decisionJson?: true
    decidedAt?: true
    decidedByJson?: true
    resumeTokenHash?: true
    expiresAt?: true
    createdAt?: true
  }

  export type HumanTaskCountAggregateInputType = {
    id?: true
    runId?: true
    workflowId?: true
    workspaceId?: true
    nodeId?: true
    activationId?: true
    itemIndex?: true
    status?: true
    channel?: true
    subjectJson?: true
    metadataJson?: true
    decisionSchemaJson?: true
    decisionSchemaHash?: true
    onTimeout?: true
    deliveryRefJson?: true
    decisionJson?: true
    decidedAt?: true
    decidedByJson?: true
    resumeTokenHash?: true
    expiresAt?: true
    createdAt?: true
    _all?: true
  }

  export type HumanTaskAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HumanTask to aggregate.
     */
    where?: HumanTaskWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of HumanTasks to fetch.
     */
    orderBy?: HumanTaskOrderByWithRelationInput | HumanTaskOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: HumanTaskWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` HumanTasks 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` HumanTasks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned HumanTasks
    **/
    _count?: true | HumanTaskCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: HumanTaskAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: HumanTaskSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: HumanTaskMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: HumanTaskMaxAggregateInputType
  }

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




  export type HumanTaskGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HumanTaskWhereInput
    orderBy?: HumanTaskOrderByWithAggregationInput | HumanTaskOrderByWithAggregationInput[]
    by: HumanTaskScalarFieldEnum[] | HumanTaskScalarFieldEnum
    having?: HumanTaskScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HumanTaskCountAggregateInputType | true
    _avg?: HumanTaskAvgAggregateInputType
    _sum?: HumanTaskSumAggregateInputType
    _min?: HumanTaskMinAggregateInputType
    _max?: HumanTaskMaxAggregateInputType
  }

  export type HumanTaskGroupByOutputType = {
    id: string
    runId: string
    workflowId: string
    workspaceId: string | null
    nodeId: string
    activationId: string
    itemIndex: number
    status: string
    channel: string
    subjectJson: string
    metadataJson: string
    decisionSchemaJson: string
    decisionSchemaHash: string
    onTimeout: string
    deliveryRefJson: string | null
    decisionJson: string | null
    decidedAt: Date | null
    decidedByJson: string | null
    resumeTokenHash: string
    expiresAt: Date
    createdAt: Date
    _count: HumanTaskCountAggregateOutputType | null
    _avg: HumanTaskAvgAggregateOutputType | null
    _sum: HumanTaskSumAggregateOutputType | null
    _min: HumanTaskMinAggregateOutputType | null
    _max: HumanTaskMaxAggregateOutputType | null
  }

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


  export type HumanTaskSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    runId?: boolean
    workflowId?: boolean
    workspaceId?: boolean
    nodeId?: boolean
    activationId?: boolean
    itemIndex?: boolean
    status?: boolean
    channel?: boolean
    subjectJson?: boolean
    metadataJson?: boolean
    decisionSchemaJson?: boolean
    decisionSchemaHash?: boolean
    onTimeout?: boolean
    deliveryRefJson?: boolean
    decisionJson?: boolean
    decidedAt?: boolean
    decidedByJson?: boolean
    resumeTokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["humanTask"]>

  export type HumanTaskSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    runId?: boolean
    workflowId?: boolean
    workspaceId?: boolean
    nodeId?: boolean
    activationId?: boolean
    itemIndex?: boolean
    status?: boolean
    channel?: boolean
    subjectJson?: boolean
    metadataJson?: boolean
    decisionSchemaJson?: boolean
    decisionSchemaHash?: boolean
    onTimeout?: boolean
    deliveryRefJson?: boolean
    decisionJson?: boolean
    decidedAt?: boolean
    decidedByJson?: boolean
    resumeTokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["humanTask"]>

  export type HumanTaskSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    runId?: boolean
    workflowId?: boolean
    workspaceId?: boolean
    nodeId?: boolean
    activationId?: boolean
    itemIndex?: boolean
    status?: boolean
    channel?: boolean
    subjectJson?: boolean
    metadataJson?: boolean
    decisionSchemaJson?: boolean
    decisionSchemaHash?: boolean
    onTimeout?: boolean
    deliveryRefJson?: boolean
    decisionJson?: boolean
    decidedAt?: boolean
    decidedByJson?: boolean
    resumeTokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["humanTask"]>

  export type HumanTaskSelectScalar = {
    id?: boolean
    runId?: boolean
    workflowId?: boolean
    workspaceId?: boolean
    nodeId?: boolean
    activationId?: boolean
    itemIndex?: boolean
    status?: boolean
    channel?: boolean
    subjectJson?: boolean
    metadataJson?: boolean
    decisionSchemaJson?: boolean
    decisionSchemaHash?: boolean
    onTimeout?: boolean
    deliveryRefJson?: boolean
    decisionJson?: boolean
    decidedAt?: boolean
    decidedByJson?: boolean
    resumeTokenHash?: boolean
    expiresAt?: boolean
    createdAt?: boolean
  }

  export type HumanTaskOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "runId" | "workflowId" | "workspaceId" | "nodeId" | "activationId" | "itemIndex" | "status" | "channel" | "subjectJson" | "metadataJson" | "decisionSchemaJson" | "decisionSchemaHash" | "onTimeout" | "deliveryRefJson" | "decisionJson" | "decidedAt" | "decidedByJson" | "resumeTokenHash" | "expiresAt" | "createdAt", ExtArgs["result"]["humanTask"]>

  export type $HumanTaskPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "HumanTask"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      runId: string
      workflowId: string
      workspaceId: string | null
      nodeId: string
      activationId: string
      itemIndex: number
      /**
       * pending | decided | timed_out | auto_accepted | cancelled
       */
      status: string
      /**
       * local | control-plane-inbox
       */
      channel: string
      subjectJson: string
      metadataJson: string
      decisionSchemaJson: string
      decisionSchemaHash: string
      /**
       * halt | auto-accept
       */
      onTimeout: string
      deliveryRefJson: string | null
      decisionJson: string | null
      decidedAt: Date | null
      decidedByJson: string | null
      resumeTokenHash: string
      expiresAt: Date
      createdAt: Date
    }, ExtArgs["result"]["humanTask"]>
    composites: {}
  }

  type HumanTaskGetPayload<S extends boolean | null | undefined | HumanTaskDefaultArgs> = $Result.GetResult<Prisma.$HumanTaskPayload, S>

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

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

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

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

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

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

    /**
     * Create a HumanTask.
     * @param {HumanTaskCreateArgs} args - Arguments to create a HumanTask.
     * @example
     * // Create one HumanTask
     * const HumanTask = await prisma.humanTask.create({
     *   data: {
     *     // ... data to create a HumanTask
     *   }
     * })
     * 
     */
    create<T extends HumanTaskCreateArgs>(args: SelectSubset<T, HumanTaskCreateArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many HumanTasks and returns the data saved in the database.
     * @param {HumanTaskCreateManyAndReturnArgs} args - Arguments to create many HumanTasks.
     * @example
     * // Create many HumanTasks
     * const humanTask = await prisma.humanTask.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many HumanTasks and only return the `id`
     * const humanTaskWithIdOnly = await prisma.humanTask.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 HumanTaskCreateManyAndReturnArgs>(args?: SelectSubset<T, HumanTaskCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a HumanTask.
     * @param {HumanTaskDeleteArgs} args - Arguments to delete one HumanTask.
     * @example
     * // Delete one HumanTask
     * const HumanTask = await prisma.humanTask.delete({
     *   where: {
     *     // ... filter to delete one HumanTask
     *   }
     * })
     * 
     */
    delete<T extends HumanTaskDeleteArgs>(args: SelectSubset<T, HumanTaskDeleteArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the HumanTask model
   */
  interface HumanTaskFieldRefs {
    readonly id: FieldRef<"HumanTask", 'String'>
    readonly runId: FieldRef<"HumanTask", 'String'>
    readonly workflowId: FieldRef<"HumanTask", 'String'>
    readonly workspaceId: FieldRef<"HumanTask", 'String'>
    readonly nodeId: FieldRef<"HumanTask", 'String'>
    readonly activationId: FieldRef<"HumanTask", 'String'>
    readonly itemIndex: FieldRef<"HumanTask", 'Int'>
    readonly status: FieldRef<"HumanTask", 'String'>
    readonly channel: FieldRef<"HumanTask", 'String'>
    readonly subjectJson: FieldRef<"HumanTask", 'String'>
    readonly metadataJson: FieldRef<"HumanTask", 'String'>
    readonly decisionSchemaJson: FieldRef<"HumanTask", 'String'>
    readonly decisionSchemaHash: FieldRef<"HumanTask", 'String'>
    readonly onTimeout: FieldRef<"HumanTask", 'String'>
    readonly deliveryRefJson: FieldRef<"HumanTask", 'String'>
    readonly decisionJson: FieldRef<"HumanTask", 'String'>
    readonly decidedAt: FieldRef<"HumanTask", 'DateTime'>
    readonly decidedByJson: FieldRef<"HumanTask", 'String'>
    readonly resumeTokenHash: FieldRef<"HumanTask", 'String'>
    readonly expiresAt: FieldRef<"HumanTask", 'DateTime'>
    readonly createdAt: FieldRef<"HumanTask", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * HumanTask findUnique
   */
  export type HumanTaskFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * Filter, which HumanTask to fetch.
     */
    where: HumanTaskWhereUniqueInput
  }

  /**
   * HumanTask findUniqueOrThrow
   */
  export type HumanTaskFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * Filter, which HumanTask to fetch.
     */
    where: HumanTaskWhereUniqueInput
  }

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

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

  /**
   * HumanTask findMany
   */
  export type HumanTaskFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * Filter, which HumanTasks to fetch.
     */
    where?: HumanTaskWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of HumanTasks to fetch.
     */
    orderBy?: HumanTaskOrderByWithRelationInput | HumanTaskOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing HumanTasks.
     */
    cursor?: HumanTaskWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` HumanTasks 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` HumanTasks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of HumanTasks.
     */
    distinct?: HumanTaskScalarFieldEnum | HumanTaskScalarFieldEnum[]
  }

  /**
   * HumanTask create
   */
  export type HumanTaskCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * The data needed to create a HumanTask.
     */
    data: XOR<HumanTaskCreateInput, HumanTaskUncheckedCreateInput>
  }

  /**
   * HumanTask createMany
   */
  export type HumanTaskCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many HumanTasks.
     */
    data: HumanTaskCreateManyInput | HumanTaskCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * HumanTask createManyAndReturn
   */
  export type HumanTaskCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * The data used to create many HumanTasks.
     */
    data: HumanTaskCreateManyInput | HumanTaskCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * HumanTask update
   */
  export type HumanTaskUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * The data needed to update a HumanTask.
     */
    data: XOR<HumanTaskUpdateInput, HumanTaskUncheckedUpdateInput>
    /**
     * Choose, which HumanTask to update.
     */
    where: HumanTaskWhereUniqueInput
  }

  /**
   * HumanTask updateMany
   */
  export type HumanTaskUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update HumanTasks.
     */
    data: XOR<HumanTaskUpdateManyMutationInput, HumanTaskUncheckedUpdateManyInput>
    /**
     * Filter which HumanTasks to update
     */
    where?: HumanTaskWhereInput
    /**
     * Limit how many HumanTasks to update.
     */
    limit?: number
  }

  /**
   * HumanTask updateManyAndReturn
   */
  export type HumanTaskUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * The data used to update HumanTasks.
     */
    data: XOR<HumanTaskUpdateManyMutationInput, HumanTaskUncheckedUpdateManyInput>
    /**
     * Filter which HumanTasks to update
     */
    where?: HumanTaskWhereInput
    /**
     * Limit how many HumanTasks to update.
     */
    limit?: number
  }

  /**
   * HumanTask upsert
   */
  export type HumanTaskUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * The filter to search for the HumanTask to update in case it exists.
     */
    where: HumanTaskWhereUniqueInput
    /**
     * In case the HumanTask found by the `where` argument doesn't exist, create a new HumanTask with this data.
     */
    create: XOR<HumanTaskCreateInput, HumanTaskUncheckedCreateInput>
    /**
     * In case the HumanTask was found with the provided `where` argument, update it with this data.
     */
    update: XOR<HumanTaskUpdateInput, HumanTaskUncheckedUpdateInput>
  }

  /**
   * HumanTask delete
   */
  export type HumanTaskDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HumanTask
     */
    select?: HumanTaskSelect<ExtArgs> | null
    /**
     * Omit specific fields from the HumanTask
     */
    omit?: HumanTaskOmit<ExtArgs> | null
    /**
     * Filter which HumanTask to delete.
     */
    where: HumanTaskWhereUniqueInput
  }

  /**
   * HumanTask deleteMany
   */
  export type HumanTaskDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HumanTasks to delete
     */
    where?: HumanTaskWhereInput
    /**
     * Limit how many HumanTasks to delete.
     */
    limit?: number
  }

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


  /**
   * Enums
   */

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

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


  export const RunScalarFieldEnum: {
    runId: 'runId',
    workflowId: 'workflowId',
    startedAt: 'startedAt',
    finishedAt: 'finishedAt',
    status: 'status',
    revision: 'revision',
    parentJson: 'parentJson',
    executionOptionsJson: 'executionOptionsJson',
    controlJson: 'controlJson',
    workflowSnapshotJson: 'workflowSnapshotJson',
    workflowSnapshotId: 'workflowSnapshotId',
    policySnapshotJson: 'policySnapshotJson',
    engineCountersJson: 'engineCountersJson',
    mutableStateJson: 'mutableStateJson',
    hitlStateJson: 'hitlStateJson',
    outputsByNodeJson: 'outputsByNodeJson',
    updatedAt: 'updatedAt',
    testSuiteRunId: 'testSuiteRunId',
    testCaseIndex: 'testCaseIndex',
    testCaseLabel: 'testCaseLabel',
    testCaseStatus: 'testCaseStatus'
  };

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


  export const RunWorkItemScalarFieldEnum: {
    workItemId: 'workItemId',
    runId: 'runId',
    workflowId: 'workflowId',
    status: 'status',
    targetNodeId: 'targetNodeId',
    batchId: 'batchId',
    queueName: 'queueName',
    claimToken: 'claimToken',
    claimedBy: 'claimedBy',
    claimedAt: 'claimedAt',
    availableAt: 'availableAt',
    enqueuedAt: 'enqueuedAt',
    completedAt: 'completedAt',
    failedAt: 'failedAt',
    sourceInstanceId: 'sourceInstanceId',
    parentInstanceId: 'parentInstanceId',
    itemsIn: 'itemsIn',
    inputsByPortJson: 'inputsByPortJson',
    errorJson: 'errorJson'
  };

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


  export const ExecutionInstanceScalarFieldEnum: {
    instanceId: 'instanceId',
    runId: 'runId',
    workflowId: 'workflowId',
    slotNodeId: 'slotNodeId',
    workflowNodeId: 'workflowNodeId',
    kind: 'kind',
    connectionKind: 'connectionKind',
    activationId: 'activationId',
    batchId: 'batchId',
    runIndex: 'runIndex',
    parentInstanceId: 'parentInstanceId',
    parentRunId: 'parentRunId',
    workerClaimToken: 'workerClaimToken',
    status: 'status',
    queuedAt: 'queuedAt',
    startedAt: 'startedAt',
    finishedAt: 'finishedAt',
    updatedAt: 'updatedAt',
    itemCount: 'itemCount',
    inputJson: 'inputJson',
    outputJson: 'outputJson',
    errorJson: 'errorJson',
    inputItemIndicesJson: 'inputItemIndicesJson',
    outputItemCount: 'outputItemCount',
    successfulItemCount: 'successfulItemCount',
    failedItemCount: 'failedItemCount',
    inputStorageKind: 'inputStorageKind',
    outputStorageKind: 'outputStorageKind',
    inputBytes: 'inputBytes',
    outputBytes: 'outputBytes',
    inputPreviewJson: 'inputPreviewJson',
    outputPreviewJson: 'outputPreviewJson',
    inputPayloadRef: 'inputPayloadRef',
    outputPayloadRef: 'outputPayloadRef',
    inputTruncated: 'inputTruncated',
    outputTruncated: 'outputTruncated',
    usedPinnedOutput: 'usedPinnedOutput',
    iterationId: 'iterationId',
    itemIndex: 'itemIndex',
    parentInvocationId: 'parentInvocationId',
    childRunId: 'childRunId'
  };

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


  export const RunSlotProjectionScalarFieldEnum: {
    runId: 'runId',
    workflowId: 'workflowId',
    revision: 'revision',
    updatedAt: 'updatedAt',
    slotStatesJson: 'slotStatesJson'
  };

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


  export const TestSuiteRunScalarFieldEnum: {
    id: 'id',
    workflowId: 'workflowId',
    triggerNodeId: 'triggerNodeId',
    triggerNodeName: 'triggerNodeName',
    status: 'status',
    concurrency: 'concurrency',
    startedAt: 'startedAt',
    finishedAt: 'finishedAt',
    totalCases: 'totalCases',
    passedCases: 'passedCases',
    failedCases: 'failedCases',
    nodeCoverageJson: 'nodeCoverageJson',
    errorMessage: 'errorMessage',
    updatedAt: 'updatedAt'
  };

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


  export const TestAssertionScalarFieldEnum: {
    id: 'id',
    runId: 'runId',
    testSuiteRunId: 'testSuiteRunId',
    workflowId: 'workflowId',
    nodeId: 'nodeId',
    iterationId: 'iterationId',
    itemIndex: 'itemIndex',
    name: 'name',
    score: 'score',
    passThreshold: 'passThreshold',
    errored: 'errored',
    expectedJson: 'expectedJson',
    actualJson: 'actualJson',
    message: 'message',
    detailsJson: 'detailsJson',
    createdAt: 'createdAt'
  };

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


  export const WorkflowDebuggerOverlayScalarFieldEnum: {
    workflowId: 'workflowId',
    updatedAt: 'updatedAt',
    copiedFromRunId: 'copiedFromRunId',
    stateJson: 'stateJson'
  };

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


  export const WorkflowActivationScalarFieldEnum: {
    workflowId: 'workflowId',
    isActive: 'isActive',
    updatedAt: 'updatedAt'
  };

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


  export const TriggerSetupStateScalarFieldEnum: {
    workflowId: 'workflowId',
    nodeId: 'nodeId',
    updatedAt: 'updatedAt',
    stateJson: 'stateJson'
  };

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


  export const RunTraceContextScalarFieldEnum: {
    runId: 'runId',
    workflowId: 'workflowId',
    traceId: 'traceId',
    rootSpanId: 'rootSpanId',
    serviceName: 'serviceName',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt'
  };

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


  export const TelemetrySpanScalarFieldEnum: {
    telemetrySpanId: 'telemetrySpanId',
    traceId: 'traceId',
    spanId: 'spanId',
    parentSpanId: 'parentSpanId',
    runId: 'runId',
    workflowId: 'workflowId',
    nodeId: 'nodeId',
    activationId: 'activationId',
    connectionInvocationId: 'connectionInvocationId',
    name: 'name',
    kind: 'kind',
    status: 'status',
    statusMessage: 'statusMessage',
    startTime: 'startTime',
    endTime: 'endTime',
    workflowFolder: 'workflowFolder',
    nodeType: 'nodeType',
    nodeRole: 'nodeRole',
    modelName: 'modelName',
    attributesJson: 'attributesJson',
    eventsJson: 'eventsJson',
    retentionExpiresAt: 'retentionExpiresAt',
    iterationId: 'iterationId',
    itemIndex: 'itemIndex',
    parentInvocationId: 'parentInvocationId',
    updatedAt: 'updatedAt'
  };

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


  export const WorkflowSnapshotScalarFieldEnum: {
    id: 'id',
    workflowId: 'workflowId',
    snapshotHash: 'snapshotHash',
    snapshotJson: 'snapshotJson',
    createdAt: 'createdAt'
  };

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


  export const TelemetryArtifactScalarFieldEnum: {
    artifactId: 'artifactId',
    traceId: 'traceId',
    spanId: 'spanId',
    runId: 'runId',
    workflowId: 'workflowId',
    nodeId: 'nodeId',
    activationId: 'activationId',
    kind: 'kind',
    contentType: 'contentType',
    previewText: 'previewText',
    previewJson: 'previewJson',
    payloadText: 'payloadText',
    payloadJson: 'payloadJson',
    payloadStorageKey: 'payloadStorageKey',
    bytes: 'bytes',
    truncated: 'truncated',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    retentionExpiresAt: 'retentionExpiresAt'
  };

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


  export const TelemetryMetricPointScalarFieldEnum: {
    metricPointId: 'metricPointId',
    traceId: 'traceId',
    spanId: 'spanId',
    runId: 'runId',
    workflowId: 'workflowId',
    nodeId: 'nodeId',
    activationId: 'activationId',
    metricName: 'metricName',
    value: 'value',
    unit: 'unit',
    observedAt: 'observedAt',
    workflowFolder: 'workflowFolder',
    nodeType: 'nodeType',
    nodeRole: 'nodeRole',
    modelName: 'modelName',
    dimensionsJson: 'dimensionsJson',
    retentionExpiresAt: 'retentionExpiresAt',
    iterationId: 'iterationId',
    itemIndex: 'itemIndex',
    parentInvocationId: 'parentInvocationId'
  };

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


  export const CredentialInstanceScalarFieldEnum: {
    instanceId: 'instanceId',
    typeId: 'typeId',
    displayName: 'displayName',
    sourceKind: 'sourceKind',
    publicConfigJson: 'publicConfigJson',
    secretRefJson: 'secretRefJson',
    tagsJson: 'tagsJson',
    setupStatus: 'setupStatus',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    materialSource: 'materialSource',
    materialRef: 'materialRef'
  };

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


  export const CredentialSecretMaterialScalarFieldEnum: {
    instanceId: 'instanceId',
    encryptedJson: 'encryptedJson',
    encryptionKeyId: 'encryptionKeyId',
    schemaVersion: 'schemaVersion',
    updatedAt: 'updatedAt'
  };

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


  export const CredentialOAuth2MaterialScalarFieldEnum: {
    instanceId: 'instanceId',
    encryptedJson: 'encryptedJson',
    encryptionKeyId: 'encryptionKeyId',
    schemaVersion: 'schemaVersion',
    providerId: 'providerId',
    connectedEmail: 'connectedEmail',
    connectedAt: 'connectedAt',
    scopesJson: 'scopesJson',
    updatedAt: 'updatedAt'
  };

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


  export const CredentialOAuth2StateScalarFieldEnum: {
    state: 'state',
    instanceId: 'instanceId',
    codeVerifier: 'codeVerifier',
    providerId: 'providerId',
    requestedScopesJson: 'requestedScopesJson',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt'
  };

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


  export const CredentialBindingScalarFieldEnum: {
    workflowId: 'workflowId',
    nodeId: 'nodeId',
    slotKey: 'slotKey',
    instanceId: 'instanceId',
    updatedAt: 'updatedAt'
  };

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


  export const CredentialTestResultScalarFieldEnum: {
    testId: 'testId',
    instanceId: 'instanceId',
    status: 'status',
    message: 'message',
    detailsJson: 'detailsJson',
    testedAt: 'testedAt',
    expiresAt: 'expiresAt'
  };

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


  export const UserScalarFieldEnum: {
    id: 'id',
    name: 'name',
    email: 'email',
    emailVerified: 'emailVerified',
    image: 'image',
    passwordHash: 'passwordHash',
    accountStatus: 'accountStatus',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const UserInviteScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    tokenHash: 'tokenHash',
    expiresAt: 'expiresAt',
    createdAt: 'createdAt',
    revokedAt: 'revokedAt'
  };

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


  export const AccountScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    type: 'type',
    provider: 'provider',
    providerAccountId: 'providerAccountId',
    password: 'password',
    refresh_token: 'refresh_token',
    access_token: 'access_token',
    expires_at: 'expires_at',
    accessTokenExpiresAt: 'accessTokenExpiresAt',
    refreshTokenExpiresAt: 'refreshTokenExpiresAt',
    token_type: 'token_type',
    scope: 'scope',
    id_token: 'id_token',
    session_state: 'session_state',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const SessionScalarFieldEnum: {
    id: 'id',
    sessionToken: 'sessionToken',
    userId: 'userId',
    expires: 'expires',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    ipAddress: 'ipAddress',
    userAgent: 'userAgent'
  };

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


  export const VerificationTokenScalarFieldEnum: {
    id: 'id',
    identifier: 'identifier',
    token: 'token',
    expires: 'expires',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const WorkflowAuditLogScalarFieldEnum: {
    id: 'id',
    occurredAt: 'occurredAt',
    actorUserId: 'actorUserId',
    actorSessionId: 'actorSessionId',
    action: 'action',
    resourceType: 'resourceType',
    resourceId: 'resourceId',
    outcome: 'outcome',
    errorCode: 'errorCode',
    correlationId: 'correlationId',
    workflowId: 'workflowId',
    runId: 'runId',
    nodeId: 'nodeId'
  };

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


  export const HmacNonceScalarFieldEnum: {
    nonce: 'nonce',
    expiresAt: 'expiresAt'
  };

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


  export const HumanTaskScalarFieldEnum: {
    id: 'id',
    runId: 'runId',
    workflowId: 'workflowId',
    workspaceId: 'workspaceId',
    nodeId: 'nodeId',
    activationId: 'activationId',
    itemIndex: 'itemIndex',
    status: 'status',
    channel: 'channel',
    subjectJson: 'subjectJson',
    metadataJson: 'metadataJson',
    decisionSchemaJson: 'decisionSchemaJson',
    decisionSchemaHash: 'decisionSchemaHash',
    onTimeout: 'onTimeout',
    deliveryRefJson: 'deliveryRefJson',
    decisionJson: 'decisionJson',
    decidedAt: 'decidedAt',
    decidedByJson: 'decidedByJson',
    resumeTokenHash: 'resumeTokenHash',
    expiresAt: 'expiresAt',
    createdAt: 'createdAt'
  };

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


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

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


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

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


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

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


  /**
   * Field references
   */


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


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


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


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


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


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


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    


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


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    
  /**
   * Deep Input Types
   */


  export type RunWhereInput = {
    AND?: RunWhereInput | RunWhereInput[]
    OR?: RunWhereInput[]
    NOT?: RunWhereInput | RunWhereInput[]
    runId?: StringFilter<"Run"> | string
    workflowId?: StringFilter<"Run"> | string
    startedAt?: StringFilter<"Run"> | string
    finishedAt?: StringNullableFilter<"Run"> | string | null
    status?: StringFilter<"Run"> | string
    revision?: IntFilter<"Run"> | number
    parentJson?: StringNullableFilter<"Run"> | string | null
    executionOptionsJson?: StringNullableFilter<"Run"> | string | null
    controlJson?: StringNullableFilter<"Run"> | string | null
    workflowSnapshotJson?: StringNullableFilter<"Run"> | string | null
    workflowSnapshotId?: StringNullableFilter<"Run"> | string | null
    policySnapshotJson?: StringNullableFilter<"Run"> | string | null
    engineCountersJson?: StringNullableFilter<"Run"> | string | null
    mutableStateJson?: StringNullableFilter<"Run"> | string | null
    hitlStateJson?: StringNullableFilter<"Run"> | string | null
    outputsByNodeJson?: StringFilter<"Run"> | string
    updatedAt?: StringFilter<"Run"> | string
    testSuiteRunId?: StringNullableFilter<"Run"> | string | null
    testCaseIndex?: IntNullableFilter<"Run"> | number | null
    testCaseLabel?: StringNullableFilter<"Run"> | string | null
    testCaseStatus?: StringNullableFilter<"Run"> | string | null
    workItems?: RunWorkItemListRelationFilter
    executionInstances?: ExecutionInstanceListRelationFilter
    slotProjection?: XOR<RunSlotProjectionNullableScalarRelationFilter, RunSlotProjectionWhereInput> | null
    testSuiteRun?: XOR<TestSuiteRunNullableScalarRelationFilter, TestSuiteRunWhereInput> | null
    testAssertions?: TestAssertionListRelationFilter
    workflowSnapshot?: XOR<WorkflowSnapshotNullableScalarRelationFilter, WorkflowSnapshotWhereInput> | null
  }

  export type RunOrderByWithRelationInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrderInput | SortOrder
    status?: SortOrder
    revision?: SortOrder
    parentJson?: SortOrderInput | SortOrder
    executionOptionsJson?: SortOrderInput | SortOrder
    controlJson?: SortOrderInput | SortOrder
    workflowSnapshotJson?: SortOrderInput | SortOrder
    workflowSnapshotId?: SortOrderInput | SortOrder
    policySnapshotJson?: SortOrderInput | SortOrder
    engineCountersJson?: SortOrderInput | SortOrder
    mutableStateJson?: SortOrderInput | SortOrder
    hitlStateJson?: SortOrderInput | SortOrder
    outputsByNodeJson?: SortOrder
    updatedAt?: SortOrder
    testSuiteRunId?: SortOrderInput | SortOrder
    testCaseIndex?: SortOrderInput | SortOrder
    testCaseLabel?: SortOrderInput | SortOrder
    testCaseStatus?: SortOrderInput | SortOrder
    workItems?: RunWorkItemOrderByRelationAggregateInput
    executionInstances?: ExecutionInstanceOrderByRelationAggregateInput
    slotProjection?: RunSlotProjectionOrderByWithRelationInput
    testSuiteRun?: TestSuiteRunOrderByWithRelationInput
    testAssertions?: TestAssertionOrderByRelationAggregateInput
    workflowSnapshot?: WorkflowSnapshotOrderByWithRelationInput
  }

  export type RunWhereUniqueInput = Prisma.AtLeast<{
    runId?: string
    AND?: RunWhereInput | RunWhereInput[]
    OR?: RunWhereInput[]
    NOT?: RunWhereInput | RunWhereInput[]
    workflowId?: StringFilter<"Run"> | string
    startedAt?: StringFilter<"Run"> | string
    finishedAt?: StringNullableFilter<"Run"> | string | null
    status?: StringFilter<"Run"> | string
    revision?: IntFilter<"Run"> | number
    parentJson?: StringNullableFilter<"Run"> | string | null
    executionOptionsJson?: StringNullableFilter<"Run"> | string | null
    controlJson?: StringNullableFilter<"Run"> | string | null
    workflowSnapshotJson?: StringNullableFilter<"Run"> | string | null
    workflowSnapshotId?: StringNullableFilter<"Run"> | string | null
    policySnapshotJson?: StringNullableFilter<"Run"> | string | null
    engineCountersJson?: StringNullableFilter<"Run"> | string | null
    mutableStateJson?: StringNullableFilter<"Run"> | string | null
    hitlStateJson?: StringNullableFilter<"Run"> | string | null
    outputsByNodeJson?: StringFilter<"Run"> | string
    updatedAt?: StringFilter<"Run"> | string
    testSuiteRunId?: StringNullableFilter<"Run"> | string | null
    testCaseIndex?: IntNullableFilter<"Run"> | number | null
    testCaseLabel?: StringNullableFilter<"Run"> | string | null
    testCaseStatus?: StringNullableFilter<"Run"> | string | null
    workItems?: RunWorkItemListRelationFilter
    executionInstances?: ExecutionInstanceListRelationFilter
    slotProjection?: XOR<RunSlotProjectionNullableScalarRelationFilter, RunSlotProjectionWhereInput> | null
    testSuiteRun?: XOR<TestSuiteRunNullableScalarRelationFilter, TestSuiteRunWhereInput> | null
    testAssertions?: TestAssertionListRelationFilter
    workflowSnapshot?: XOR<WorkflowSnapshotNullableScalarRelationFilter, WorkflowSnapshotWhereInput> | null
  }, "runId">

  export type RunOrderByWithAggregationInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrderInput | SortOrder
    status?: SortOrder
    revision?: SortOrder
    parentJson?: SortOrderInput | SortOrder
    executionOptionsJson?: SortOrderInput | SortOrder
    controlJson?: SortOrderInput | SortOrder
    workflowSnapshotJson?: SortOrderInput | SortOrder
    workflowSnapshotId?: SortOrderInput | SortOrder
    policySnapshotJson?: SortOrderInput | SortOrder
    engineCountersJson?: SortOrderInput | SortOrder
    mutableStateJson?: SortOrderInput | SortOrder
    hitlStateJson?: SortOrderInput | SortOrder
    outputsByNodeJson?: SortOrder
    updatedAt?: SortOrder
    testSuiteRunId?: SortOrderInput | SortOrder
    testCaseIndex?: SortOrderInput | SortOrder
    testCaseLabel?: SortOrderInput | SortOrder
    testCaseStatus?: SortOrderInput | SortOrder
    _count?: RunCountOrderByAggregateInput
    _avg?: RunAvgOrderByAggregateInput
    _max?: RunMaxOrderByAggregateInput
    _min?: RunMinOrderByAggregateInput
    _sum?: RunSumOrderByAggregateInput
  }

  export type RunScalarWhereWithAggregatesInput = {
    AND?: RunScalarWhereWithAggregatesInput | RunScalarWhereWithAggregatesInput[]
    OR?: RunScalarWhereWithAggregatesInput[]
    NOT?: RunScalarWhereWithAggregatesInput | RunScalarWhereWithAggregatesInput[]
    runId?: StringWithAggregatesFilter<"Run"> | string
    workflowId?: StringWithAggregatesFilter<"Run"> | string
    startedAt?: StringWithAggregatesFilter<"Run"> | string
    finishedAt?: StringNullableWithAggregatesFilter<"Run"> | string | null
    status?: StringWithAggregatesFilter<"Run"> | string
    revision?: IntWithAggregatesFilter<"Run"> | number
    parentJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    executionOptionsJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    controlJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    workflowSnapshotJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    workflowSnapshotId?: StringNullableWithAggregatesFilter<"Run"> | string | null
    policySnapshotJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    engineCountersJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    mutableStateJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    hitlStateJson?: StringNullableWithAggregatesFilter<"Run"> | string | null
    outputsByNodeJson?: StringWithAggregatesFilter<"Run"> | string
    updatedAt?: StringWithAggregatesFilter<"Run"> | string
    testSuiteRunId?: StringNullableWithAggregatesFilter<"Run"> | string | null
    testCaseIndex?: IntNullableWithAggregatesFilter<"Run"> | number | null
    testCaseLabel?: StringNullableWithAggregatesFilter<"Run"> | string | null
    testCaseStatus?: StringNullableWithAggregatesFilter<"Run"> | string | null
  }

  export type RunWorkItemWhereInput = {
    AND?: RunWorkItemWhereInput | RunWorkItemWhereInput[]
    OR?: RunWorkItemWhereInput[]
    NOT?: RunWorkItemWhereInput | RunWorkItemWhereInput[]
    workItemId?: StringFilter<"RunWorkItem"> | string
    runId?: StringFilter<"RunWorkItem"> | string
    workflowId?: StringFilter<"RunWorkItem"> | string
    status?: StringFilter<"RunWorkItem"> | string
    targetNodeId?: StringFilter<"RunWorkItem"> | string
    batchId?: StringFilter<"RunWorkItem"> | string
    queueName?: StringNullableFilter<"RunWorkItem"> | string | null
    claimToken?: StringNullableFilter<"RunWorkItem"> | string | null
    claimedBy?: StringNullableFilter<"RunWorkItem"> | string | null
    claimedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    availableAt?: StringFilter<"RunWorkItem"> | string
    enqueuedAt?: StringFilter<"RunWorkItem"> | string
    completedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    failedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    sourceInstanceId?: StringNullableFilter<"RunWorkItem"> | string | null
    parentInstanceId?: StringNullableFilter<"RunWorkItem"> | string | null
    itemsIn?: IntFilter<"RunWorkItem"> | number
    inputsByPortJson?: StringFilter<"RunWorkItem"> | string
    errorJson?: StringNullableFilter<"RunWorkItem"> | string | null
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
  }

  export type RunWorkItemOrderByWithRelationInput = {
    workItemId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    status?: SortOrder
    targetNodeId?: SortOrder
    batchId?: SortOrder
    queueName?: SortOrderInput | SortOrder
    claimToken?: SortOrderInput | SortOrder
    claimedBy?: SortOrderInput | SortOrder
    claimedAt?: SortOrderInput | SortOrder
    availableAt?: SortOrder
    enqueuedAt?: SortOrder
    completedAt?: SortOrderInput | SortOrder
    failedAt?: SortOrderInput | SortOrder
    sourceInstanceId?: SortOrderInput | SortOrder
    parentInstanceId?: SortOrderInput | SortOrder
    itemsIn?: SortOrder
    inputsByPortJson?: SortOrder
    errorJson?: SortOrderInput | SortOrder
    run?: RunOrderByWithRelationInput
  }

  export type RunWorkItemWhereUniqueInput = Prisma.AtLeast<{
    workItemId?: string
    AND?: RunWorkItemWhereInput | RunWorkItemWhereInput[]
    OR?: RunWorkItemWhereInput[]
    NOT?: RunWorkItemWhereInput | RunWorkItemWhereInput[]
    runId?: StringFilter<"RunWorkItem"> | string
    workflowId?: StringFilter<"RunWorkItem"> | string
    status?: StringFilter<"RunWorkItem"> | string
    targetNodeId?: StringFilter<"RunWorkItem"> | string
    batchId?: StringFilter<"RunWorkItem"> | string
    queueName?: StringNullableFilter<"RunWorkItem"> | string | null
    claimToken?: StringNullableFilter<"RunWorkItem"> | string | null
    claimedBy?: StringNullableFilter<"RunWorkItem"> | string | null
    claimedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    availableAt?: StringFilter<"RunWorkItem"> | string
    enqueuedAt?: StringFilter<"RunWorkItem"> | string
    completedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    failedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    sourceInstanceId?: StringNullableFilter<"RunWorkItem"> | string | null
    parentInstanceId?: StringNullableFilter<"RunWorkItem"> | string | null
    itemsIn?: IntFilter<"RunWorkItem"> | number
    inputsByPortJson?: StringFilter<"RunWorkItem"> | string
    errorJson?: StringNullableFilter<"RunWorkItem"> | string | null
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
  }, "workItemId">

  export type RunWorkItemOrderByWithAggregationInput = {
    workItemId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    status?: SortOrder
    targetNodeId?: SortOrder
    batchId?: SortOrder
    queueName?: SortOrderInput | SortOrder
    claimToken?: SortOrderInput | SortOrder
    claimedBy?: SortOrderInput | SortOrder
    claimedAt?: SortOrderInput | SortOrder
    availableAt?: SortOrder
    enqueuedAt?: SortOrder
    completedAt?: SortOrderInput | SortOrder
    failedAt?: SortOrderInput | SortOrder
    sourceInstanceId?: SortOrderInput | SortOrder
    parentInstanceId?: SortOrderInput | SortOrder
    itemsIn?: SortOrder
    inputsByPortJson?: SortOrder
    errorJson?: SortOrderInput | SortOrder
    _count?: RunWorkItemCountOrderByAggregateInput
    _avg?: RunWorkItemAvgOrderByAggregateInput
    _max?: RunWorkItemMaxOrderByAggregateInput
    _min?: RunWorkItemMinOrderByAggregateInput
    _sum?: RunWorkItemSumOrderByAggregateInput
  }

  export type RunWorkItemScalarWhereWithAggregatesInput = {
    AND?: RunWorkItemScalarWhereWithAggregatesInput | RunWorkItemScalarWhereWithAggregatesInput[]
    OR?: RunWorkItemScalarWhereWithAggregatesInput[]
    NOT?: RunWorkItemScalarWhereWithAggregatesInput | RunWorkItemScalarWhereWithAggregatesInput[]
    workItemId?: StringWithAggregatesFilter<"RunWorkItem"> | string
    runId?: StringWithAggregatesFilter<"RunWorkItem"> | string
    workflowId?: StringWithAggregatesFilter<"RunWorkItem"> | string
    status?: StringWithAggregatesFilter<"RunWorkItem"> | string
    targetNodeId?: StringWithAggregatesFilter<"RunWorkItem"> | string
    batchId?: StringWithAggregatesFilter<"RunWorkItem"> | string
    queueName?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    claimToken?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    claimedBy?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    claimedAt?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    availableAt?: StringWithAggregatesFilter<"RunWorkItem"> | string
    enqueuedAt?: StringWithAggregatesFilter<"RunWorkItem"> | string
    completedAt?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    failedAt?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    sourceInstanceId?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    parentInstanceId?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
    itemsIn?: IntWithAggregatesFilter<"RunWorkItem"> | number
    inputsByPortJson?: StringWithAggregatesFilter<"RunWorkItem"> | string
    errorJson?: StringNullableWithAggregatesFilter<"RunWorkItem"> | string | null
  }

  export type ExecutionInstanceWhereInput = {
    AND?: ExecutionInstanceWhereInput | ExecutionInstanceWhereInput[]
    OR?: ExecutionInstanceWhereInput[]
    NOT?: ExecutionInstanceWhereInput | ExecutionInstanceWhereInput[]
    instanceId?: StringFilter<"ExecutionInstance"> | string
    runId?: StringFilter<"ExecutionInstance"> | string
    workflowId?: StringFilter<"ExecutionInstance"> | string
    slotNodeId?: StringFilter<"ExecutionInstance"> | string
    workflowNodeId?: StringFilter<"ExecutionInstance"> | string
    kind?: StringFilter<"ExecutionInstance"> | string
    connectionKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    activationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    batchId?: StringFilter<"ExecutionInstance"> | string
    runIndex?: IntFilter<"ExecutionInstance"> | number
    parentInstanceId?: StringNullableFilter<"ExecutionInstance"> | string | null
    parentRunId?: StringNullableFilter<"ExecutionInstance"> | string | null
    workerClaimToken?: StringNullableFilter<"ExecutionInstance"> | string | null
    status?: StringFilter<"ExecutionInstance"> | string
    queuedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    startedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    finishedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    updatedAt?: StringFilter<"ExecutionInstance"> | string
    itemCount?: IntFilter<"ExecutionInstance"> | number
    inputJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    errorJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputItemIndicesJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    successfulItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    failedItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    inputStorageKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputStorageKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputBytes?: IntNullableFilter<"ExecutionInstance"> | number | null
    outputBytes?: IntNullableFilter<"ExecutionInstance"> | number | null
    inputPreviewJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputPreviewJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputPayloadRef?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputPayloadRef?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputTruncated?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    outputTruncated?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    usedPinnedOutput?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    iterationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    itemIndex?: IntNullableFilter<"ExecutionInstance"> | number | null
    parentInvocationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    childRunId?: StringNullableFilter<"ExecutionInstance"> | string | null
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
  }

  export type ExecutionInstanceOrderByWithRelationInput = {
    instanceId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    slotNodeId?: SortOrder
    workflowNodeId?: SortOrder
    kind?: SortOrder
    connectionKind?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    batchId?: SortOrder
    runIndex?: SortOrder
    parentInstanceId?: SortOrderInput | SortOrder
    parentRunId?: SortOrderInput | SortOrder
    workerClaimToken?: SortOrderInput | SortOrder
    status?: SortOrder
    queuedAt?: SortOrderInput | SortOrder
    startedAt?: SortOrderInput | SortOrder
    finishedAt?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    itemCount?: SortOrder
    inputJson?: SortOrderInput | SortOrder
    outputJson?: SortOrderInput | SortOrder
    errorJson?: SortOrderInput | SortOrder
    inputItemIndicesJson?: SortOrderInput | SortOrder
    outputItemCount?: SortOrderInput | SortOrder
    successfulItemCount?: SortOrderInput | SortOrder
    failedItemCount?: SortOrderInput | SortOrder
    inputStorageKind?: SortOrderInput | SortOrder
    outputStorageKind?: SortOrderInput | SortOrder
    inputBytes?: SortOrderInput | SortOrder
    outputBytes?: SortOrderInput | SortOrder
    inputPreviewJson?: SortOrderInput | SortOrder
    outputPreviewJson?: SortOrderInput | SortOrder
    inputPayloadRef?: SortOrderInput | SortOrder
    outputPayloadRef?: SortOrderInput | SortOrder
    inputTruncated?: SortOrderInput | SortOrder
    outputTruncated?: SortOrderInput | SortOrder
    usedPinnedOutput?: SortOrderInput | SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    parentInvocationId?: SortOrderInput | SortOrder
    childRunId?: SortOrderInput | SortOrder
    run?: RunOrderByWithRelationInput
  }

  export type ExecutionInstanceWhereUniqueInput = Prisma.AtLeast<{
    instanceId?: string
    runId_slotNodeId_runIndex?: ExecutionInstanceRunIdSlotNodeIdRunIndexCompoundUniqueInput
    AND?: ExecutionInstanceWhereInput | ExecutionInstanceWhereInput[]
    OR?: ExecutionInstanceWhereInput[]
    NOT?: ExecutionInstanceWhereInput | ExecutionInstanceWhereInput[]
    runId?: StringFilter<"ExecutionInstance"> | string
    workflowId?: StringFilter<"ExecutionInstance"> | string
    slotNodeId?: StringFilter<"ExecutionInstance"> | string
    workflowNodeId?: StringFilter<"ExecutionInstance"> | string
    kind?: StringFilter<"ExecutionInstance"> | string
    connectionKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    activationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    batchId?: StringFilter<"ExecutionInstance"> | string
    runIndex?: IntFilter<"ExecutionInstance"> | number
    parentInstanceId?: StringNullableFilter<"ExecutionInstance"> | string | null
    parentRunId?: StringNullableFilter<"ExecutionInstance"> | string | null
    workerClaimToken?: StringNullableFilter<"ExecutionInstance"> | string | null
    status?: StringFilter<"ExecutionInstance"> | string
    queuedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    startedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    finishedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    updatedAt?: StringFilter<"ExecutionInstance"> | string
    itemCount?: IntFilter<"ExecutionInstance"> | number
    inputJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    errorJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputItemIndicesJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    successfulItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    failedItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    inputStorageKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputStorageKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputBytes?: IntNullableFilter<"ExecutionInstance"> | number | null
    outputBytes?: IntNullableFilter<"ExecutionInstance"> | number | null
    inputPreviewJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputPreviewJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputPayloadRef?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputPayloadRef?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputTruncated?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    outputTruncated?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    usedPinnedOutput?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    iterationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    itemIndex?: IntNullableFilter<"ExecutionInstance"> | number | null
    parentInvocationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    childRunId?: StringNullableFilter<"ExecutionInstance"> | string | null
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
  }, "instanceId" | "runId_slotNodeId_runIndex">

  export type ExecutionInstanceOrderByWithAggregationInput = {
    instanceId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    slotNodeId?: SortOrder
    workflowNodeId?: SortOrder
    kind?: SortOrder
    connectionKind?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    batchId?: SortOrder
    runIndex?: SortOrder
    parentInstanceId?: SortOrderInput | SortOrder
    parentRunId?: SortOrderInput | SortOrder
    workerClaimToken?: SortOrderInput | SortOrder
    status?: SortOrder
    queuedAt?: SortOrderInput | SortOrder
    startedAt?: SortOrderInput | SortOrder
    finishedAt?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    itemCount?: SortOrder
    inputJson?: SortOrderInput | SortOrder
    outputJson?: SortOrderInput | SortOrder
    errorJson?: SortOrderInput | SortOrder
    inputItemIndicesJson?: SortOrderInput | SortOrder
    outputItemCount?: SortOrderInput | SortOrder
    successfulItemCount?: SortOrderInput | SortOrder
    failedItemCount?: SortOrderInput | SortOrder
    inputStorageKind?: SortOrderInput | SortOrder
    outputStorageKind?: SortOrderInput | SortOrder
    inputBytes?: SortOrderInput | SortOrder
    outputBytes?: SortOrderInput | SortOrder
    inputPreviewJson?: SortOrderInput | SortOrder
    outputPreviewJson?: SortOrderInput | SortOrder
    inputPayloadRef?: SortOrderInput | SortOrder
    outputPayloadRef?: SortOrderInput | SortOrder
    inputTruncated?: SortOrderInput | SortOrder
    outputTruncated?: SortOrderInput | SortOrder
    usedPinnedOutput?: SortOrderInput | SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    parentInvocationId?: SortOrderInput | SortOrder
    childRunId?: SortOrderInput | SortOrder
    _count?: ExecutionInstanceCountOrderByAggregateInput
    _avg?: ExecutionInstanceAvgOrderByAggregateInput
    _max?: ExecutionInstanceMaxOrderByAggregateInput
    _min?: ExecutionInstanceMinOrderByAggregateInput
    _sum?: ExecutionInstanceSumOrderByAggregateInput
  }

  export type ExecutionInstanceScalarWhereWithAggregatesInput = {
    AND?: ExecutionInstanceScalarWhereWithAggregatesInput | ExecutionInstanceScalarWhereWithAggregatesInput[]
    OR?: ExecutionInstanceScalarWhereWithAggregatesInput[]
    NOT?: ExecutionInstanceScalarWhereWithAggregatesInput | ExecutionInstanceScalarWhereWithAggregatesInput[]
    instanceId?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    runId?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    workflowId?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    slotNodeId?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    workflowNodeId?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    kind?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    connectionKind?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    activationId?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    batchId?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    runIndex?: IntWithAggregatesFilter<"ExecutionInstance"> | number
    parentInstanceId?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    parentRunId?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    workerClaimToken?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    status?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    queuedAt?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    startedAt?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    finishedAt?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    updatedAt?: StringWithAggregatesFilter<"ExecutionInstance"> | string
    itemCount?: IntWithAggregatesFilter<"ExecutionInstance"> | number
    inputJson?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    outputJson?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    errorJson?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    inputItemIndicesJson?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    outputItemCount?: IntNullableWithAggregatesFilter<"ExecutionInstance"> | number | null
    successfulItemCount?: IntNullableWithAggregatesFilter<"ExecutionInstance"> | number | null
    failedItemCount?: IntNullableWithAggregatesFilter<"ExecutionInstance"> | number | null
    inputStorageKind?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    outputStorageKind?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    inputBytes?: IntNullableWithAggregatesFilter<"ExecutionInstance"> | number | null
    outputBytes?: IntNullableWithAggregatesFilter<"ExecutionInstance"> | number | null
    inputPreviewJson?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    outputPreviewJson?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    inputPayloadRef?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    outputPayloadRef?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    inputTruncated?: BoolNullableWithAggregatesFilter<"ExecutionInstance"> | boolean | null
    outputTruncated?: BoolNullableWithAggregatesFilter<"ExecutionInstance"> | boolean | null
    usedPinnedOutput?: BoolNullableWithAggregatesFilter<"ExecutionInstance"> | boolean | null
    iterationId?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    itemIndex?: IntNullableWithAggregatesFilter<"ExecutionInstance"> | number | null
    parentInvocationId?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
    childRunId?: StringNullableWithAggregatesFilter<"ExecutionInstance"> | string | null
  }

  export type RunSlotProjectionWhereInput = {
    AND?: RunSlotProjectionWhereInput | RunSlotProjectionWhereInput[]
    OR?: RunSlotProjectionWhereInput[]
    NOT?: RunSlotProjectionWhereInput | RunSlotProjectionWhereInput[]
    runId?: StringFilter<"RunSlotProjection"> | string
    workflowId?: StringFilter<"RunSlotProjection"> | string
    revision?: IntFilter<"RunSlotProjection"> | number
    updatedAt?: StringFilter<"RunSlotProjection"> | string
    slotStatesJson?: StringFilter<"RunSlotProjection"> | string
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
  }

  export type RunSlotProjectionOrderByWithRelationInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    revision?: SortOrder
    updatedAt?: SortOrder
    slotStatesJson?: SortOrder
    run?: RunOrderByWithRelationInput
  }

  export type RunSlotProjectionWhereUniqueInput = Prisma.AtLeast<{
    runId?: string
    AND?: RunSlotProjectionWhereInput | RunSlotProjectionWhereInput[]
    OR?: RunSlotProjectionWhereInput[]
    NOT?: RunSlotProjectionWhereInput | RunSlotProjectionWhereInput[]
    workflowId?: StringFilter<"RunSlotProjection"> | string
    revision?: IntFilter<"RunSlotProjection"> | number
    updatedAt?: StringFilter<"RunSlotProjection"> | string
    slotStatesJson?: StringFilter<"RunSlotProjection"> | string
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
  }, "runId">

  export type RunSlotProjectionOrderByWithAggregationInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    revision?: SortOrder
    updatedAt?: SortOrder
    slotStatesJson?: SortOrder
    _count?: RunSlotProjectionCountOrderByAggregateInput
    _avg?: RunSlotProjectionAvgOrderByAggregateInput
    _max?: RunSlotProjectionMaxOrderByAggregateInput
    _min?: RunSlotProjectionMinOrderByAggregateInput
    _sum?: RunSlotProjectionSumOrderByAggregateInput
  }

  export type RunSlotProjectionScalarWhereWithAggregatesInput = {
    AND?: RunSlotProjectionScalarWhereWithAggregatesInput | RunSlotProjectionScalarWhereWithAggregatesInput[]
    OR?: RunSlotProjectionScalarWhereWithAggregatesInput[]
    NOT?: RunSlotProjectionScalarWhereWithAggregatesInput | RunSlotProjectionScalarWhereWithAggregatesInput[]
    runId?: StringWithAggregatesFilter<"RunSlotProjection"> | string
    workflowId?: StringWithAggregatesFilter<"RunSlotProjection"> | string
    revision?: IntWithAggregatesFilter<"RunSlotProjection"> | number
    updatedAt?: StringWithAggregatesFilter<"RunSlotProjection"> | string
    slotStatesJson?: StringWithAggregatesFilter<"RunSlotProjection"> | string
  }

  export type TestSuiteRunWhereInput = {
    AND?: TestSuiteRunWhereInput | TestSuiteRunWhereInput[]
    OR?: TestSuiteRunWhereInput[]
    NOT?: TestSuiteRunWhereInput | TestSuiteRunWhereInput[]
    id?: StringFilter<"TestSuiteRun"> | string
    workflowId?: StringFilter<"TestSuiteRun"> | string
    triggerNodeId?: StringFilter<"TestSuiteRun"> | string
    triggerNodeName?: StringNullableFilter<"TestSuiteRun"> | string | null
    status?: StringFilter<"TestSuiteRun"> | string
    concurrency?: IntFilter<"TestSuiteRun"> | number
    startedAt?: StringFilter<"TestSuiteRun"> | string
    finishedAt?: StringNullableFilter<"TestSuiteRun"> | string | null
    totalCases?: IntFilter<"TestSuiteRun"> | number
    passedCases?: IntFilter<"TestSuiteRun"> | number
    failedCases?: IntFilter<"TestSuiteRun"> | number
    nodeCoverageJson?: StringNullableFilter<"TestSuiteRun"> | string | null
    errorMessage?: StringNullableFilter<"TestSuiteRun"> | string | null
    updatedAt?: StringFilter<"TestSuiteRun"> | string
    runs?: RunListRelationFilter
    assertions?: TestAssertionListRelationFilter
  }

  export type TestSuiteRunOrderByWithRelationInput = {
    id?: SortOrder
    workflowId?: SortOrder
    triggerNodeId?: SortOrder
    triggerNodeName?: SortOrderInput | SortOrder
    status?: SortOrder
    concurrency?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrderInput | SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
    nodeCoverageJson?: SortOrderInput | SortOrder
    errorMessage?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    runs?: RunOrderByRelationAggregateInput
    assertions?: TestAssertionOrderByRelationAggregateInput
  }

  export type TestSuiteRunWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TestSuiteRunWhereInput | TestSuiteRunWhereInput[]
    OR?: TestSuiteRunWhereInput[]
    NOT?: TestSuiteRunWhereInput | TestSuiteRunWhereInput[]
    workflowId?: StringFilter<"TestSuiteRun"> | string
    triggerNodeId?: StringFilter<"TestSuiteRun"> | string
    triggerNodeName?: StringNullableFilter<"TestSuiteRun"> | string | null
    status?: StringFilter<"TestSuiteRun"> | string
    concurrency?: IntFilter<"TestSuiteRun"> | number
    startedAt?: StringFilter<"TestSuiteRun"> | string
    finishedAt?: StringNullableFilter<"TestSuiteRun"> | string | null
    totalCases?: IntFilter<"TestSuiteRun"> | number
    passedCases?: IntFilter<"TestSuiteRun"> | number
    failedCases?: IntFilter<"TestSuiteRun"> | number
    nodeCoverageJson?: StringNullableFilter<"TestSuiteRun"> | string | null
    errorMessage?: StringNullableFilter<"TestSuiteRun"> | string | null
    updatedAt?: StringFilter<"TestSuiteRun"> | string
    runs?: RunListRelationFilter
    assertions?: TestAssertionListRelationFilter
  }, "id">

  export type TestSuiteRunOrderByWithAggregationInput = {
    id?: SortOrder
    workflowId?: SortOrder
    triggerNodeId?: SortOrder
    triggerNodeName?: SortOrderInput | SortOrder
    status?: SortOrder
    concurrency?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrderInput | SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
    nodeCoverageJson?: SortOrderInput | SortOrder
    errorMessage?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    _count?: TestSuiteRunCountOrderByAggregateInput
    _avg?: TestSuiteRunAvgOrderByAggregateInput
    _max?: TestSuiteRunMaxOrderByAggregateInput
    _min?: TestSuiteRunMinOrderByAggregateInput
    _sum?: TestSuiteRunSumOrderByAggregateInput
  }

  export type TestSuiteRunScalarWhereWithAggregatesInput = {
    AND?: TestSuiteRunScalarWhereWithAggregatesInput | TestSuiteRunScalarWhereWithAggregatesInput[]
    OR?: TestSuiteRunScalarWhereWithAggregatesInput[]
    NOT?: TestSuiteRunScalarWhereWithAggregatesInput | TestSuiteRunScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"TestSuiteRun"> | string
    workflowId?: StringWithAggregatesFilter<"TestSuiteRun"> | string
    triggerNodeId?: StringWithAggregatesFilter<"TestSuiteRun"> | string
    triggerNodeName?: StringNullableWithAggregatesFilter<"TestSuiteRun"> | string | null
    status?: StringWithAggregatesFilter<"TestSuiteRun"> | string
    concurrency?: IntWithAggregatesFilter<"TestSuiteRun"> | number
    startedAt?: StringWithAggregatesFilter<"TestSuiteRun"> | string
    finishedAt?: StringNullableWithAggregatesFilter<"TestSuiteRun"> | string | null
    totalCases?: IntWithAggregatesFilter<"TestSuiteRun"> | number
    passedCases?: IntWithAggregatesFilter<"TestSuiteRun"> | number
    failedCases?: IntWithAggregatesFilter<"TestSuiteRun"> | number
    nodeCoverageJson?: StringNullableWithAggregatesFilter<"TestSuiteRun"> | string | null
    errorMessage?: StringNullableWithAggregatesFilter<"TestSuiteRun"> | string | null
    updatedAt?: StringWithAggregatesFilter<"TestSuiteRun"> | string
  }

  export type TestAssertionWhereInput = {
    AND?: TestAssertionWhereInput | TestAssertionWhereInput[]
    OR?: TestAssertionWhereInput[]
    NOT?: TestAssertionWhereInput | TestAssertionWhereInput[]
    id?: StringFilter<"TestAssertion"> | string
    runId?: StringFilter<"TestAssertion"> | string
    testSuiteRunId?: StringFilter<"TestAssertion"> | string
    workflowId?: StringFilter<"TestAssertion"> | string
    nodeId?: StringFilter<"TestAssertion"> | string
    iterationId?: StringNullableFilter<"TestAssertion"> | string | null
    itemIndex?: IntNullableFilter<"TestAssertion"> | number | null
    name?: StringFilter<"TestAssertion"> | string
    score?: FloatFilter<"TestAssertion"> | number
    passThreshold?: FloatNullableFilter<"TestAssertion"> | number | null
    errored?: BoolFilter<"TestAssertion"> | boolean
    expectedJson?: StringNullableFilter<"TestAssertion"> | string | null
    actualJson?: StringNullableFilter<"TestAssertion"> | string | null
    message?: StringNullableFilter<"TestAssertion"> | string | null
    detailsJson?: StringNullableFilter<"TestAssertion"> | string | null
    createdAt?: StringFilter<"TestAssertion"> | string
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
    testSuiteRun?: XOR<TestSuiteRunScalarRelationFilter, TestSuiteRunWhereInput>
  }

  export type TestAssertionOrderByWithRelationInput = {
    id?: SortOrder
    runId?: SortOrder
    testSuiteRunId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    name?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrderInput | SortOrder
    errored?: SortOrder
    expectedJson?: SortOrderInput | SortOrder
    actualJson?: SortOrderInput | SortOrder
    message?: SortOrderInput | SortOrder
    detailsJson?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    run?: RunOrderByWithRelationInput
    testSuiteRun?: TestSuiteRunOrderByWithRelationInput
  }

  export type TestAssertionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TestAssertionWhereInput | TestAssertionWhereInput[]
    OR?: TestAssertionWhereInput[]
    NOT?: TestAssertionWhereInput | TestAssertionWhereInput[]
    runId?: StringFilter<"TestAssertion"> | string
    testSuiteRunId?: StringFilter<"TestAssertion"> | string
    workflowId?: StringFilter<"TestAssertion"> | string
    nodeId?: StringFilter<"TestAssertion"> | string
    iterationId?: StringNullableFilter<"TestAssertion"> | string | null
    itemIndex?: IntNullableFilter<"TestAssertion"> | number | null
    name?: StringFilter<"TestAssertion"> | string
    score?: FloatFilter<"TestAssertion"> | number
    passThreshold?: FloatNullableFilter<"TestAssertion"> | number | null
    errored?: BoolFilter<"TestAssertion"> | boolean
    expectedJson?: StringNullableFilter<"TestAssertion"> | string | null
    actualJson?: StringNullableFilter<"TestAssertion"> | string | null
    message?: StringNullableFilter<"TestAssertion"> | string | null
    detailsJson?: StringNullableFilter<"TestAssertion"> | string | null
    createdAt?: StringFilter<"TestAssertion"> | string
    run?: XOR<RunScalarRelationFilter, RunWhereInput>
    testSuiteRun?: XOR<TestSuiteRunScalarRelationFilter, TestSuiteRunWhereInput>
  }, "id">

  export type TestAssertionOrderByWithAggregationInput = {
    id?: SortOrder
    runId?: SortOrder
    testSuiteRunId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    name?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrderInput | SortOrder
    errored?: SortOrder
    expectedJson?: SortOrderInput | SortOrder
    actualJson?: SortOrderInput | SortOrder
    message?: SortOrderInput | SortOrder
    detailsJson?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: TestAssertionCountOrderByAggregateInput
    _avg?: TestAssertionAvgOrderByAggregateInput
    _max?: TestAssertionMaxOrderByAggregateInput
    _min?: TestAssertionMinOrderByAggregateInput
    _sum?: TestAssertionSumOrderByAggregateInput
  }

  export type TestAssertionScalarWhereWithAggregatesInput = {
    AND?: TestAssertionScalarWhereWithAggregatesInput | TestAssertionScalarWhereWithAggregatesInput[]
    OR?: TestAssertionScalarWhereWithAggregatesInput[]
    NOT?: TestAssertionScalarWhereWithAggregatesInput | TestAssertionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"TestAssertion"> | string
    runId?: StringWithAggregatesFilter<"TestAssertion"> | string
    testSuiteRunId?: StringWithAggregatesFilter<"TestAssertion"> | string
    workflowId?: StringWithAggregatesFilter<"TestAssertion"> | string
    nodeId?: StringWithAggregatesFilter<"TestAssertion"> | string
    iterationId?: StringNullableWithAggregatesFilter<"TestAssertion"> | string | null
    itemIndex?: IntNullableWithAggregatesFilter<"TestAssertion"> | number | null
    name?: StringWithAggregatesFilter<"TestAssertion"> | string
    score?: FloatWithAggregatesFilter<"TestAssertion"> | number
    passThreshold?: FloatNullableWithAggregatesFilter<"TestAssertion"> | number | null
    errored?: BoolWithAggregatesFilter<"TestAssertion"> | boolean
    expectedJson?: StringNullableWithAggregatesFilter<"TestAssertion"> | string | null
    actualJson?: StringNullableWithAggregatesFilter<"TestAssertion"> | string | null
    message?: StringNullableWithAggregatesFilter<"TestAssertion"> | string | null
    detailsJson?: StringNullableWithAggregatesFilter<"TestAssertion"> | string | null
    createdAt?: StringWithAggregatesFilter<"TestAssertion"> | string
  }

  export type WorkflowDebuggerOverlayWhereInput = {
    AND?: WorkflowDebuggerOverlayWhereInput | WorkflowDebuggerOverlayWhereInput[]
    OR?: WorkflowDebuggerOverlayWhereInput[]
    NOT?: WorkflowDebuggerOverlayWhereInput | WorkflowDebuggerOverlayWhereInput[]
    workflowId?: StringFilter<"WorkflowDebuggerOverlay"> | string
    updatedAt?: StringFilter<"WorkflowDebuggerOverlay"> | string
    copiedFromRunId?: StringNullableFilter<"WorkflowDebuggerOverlay"> | string | null
    stateJson?: StringFilter<"WorkflowDebuggerOverlay"> | string
  }

  export type WorkflowDebuggerOverlayOrderByWithRelationInput = {
    workflowId?: SortOrder
    updatedAt?: SortOrder
    copiedFromRunId?: SortOrderInput | SortOrder
    stateJson?: SortOrder
  }

  export type WorkflowDebuggerOverlayWhereUniqueInput = Prisma.AtLeast<{
    workflowId?: string
    AND?: WorkflowDebuggerOverlayWhereInput | WorkflowDebuggerOverlayWhereInput[]
    OR?: WorkflowDebuggerOverlayWhereInput[]
    NOT?: WorkflowDebuggerOverlayWhereInput | WorkflowDebuggerOverlayWhereInput[]
    updatedAt?: StringFilter<"WorkflowDebuggerOverlay"> | string
    copiedFromRunId?: StringNullableFilter<"WorkflowDebuggerOverlay"> | string | null
    stateJson?: StringFilter<"WorkflowDebuggerOverlay"> | string
  }, "workflowId">

  export type WorkflowDebuggerOverlayOrderByWithAggregationInput = {
    workflowId?: SortOrder
    updatedAt?: SortOrder
    copiedFromRunId?: SortOrderInput | SortOrder
    stateJson?: SortOrder
    _count?: WorkflowDebuggerOverlayCountOrderByAggregateInput
    _max?: WorkflowDebuggerOverlayMaxOrderByAggregateInput
    _min?: WorkflowDebuggerOverlayMinOrderByAggregateInput
  }

  export type WorkflowDebuggerOverlayScalarWhereWithAggregatesInput = {
    AND?: WorkflowDebuggerOverlayScalarWhereWithAggregatesInput | WorkflowDebuggerOverlayScalarWhereWithAggregatesInput[]
    OR?: WorkflowDebuggerOverlayScalarWhereWithAggregatesInput[]
    NOT?: WorkflowDebuggerOverlayScalarWhereWithAggregatesInput | WorkflowDebuggerOverlayScalarWhereWithAggregatesInput[]
    workflowId?: StringWithAggregatesFilter<"WorkflowDebuggerOverlay"> | string
    updatedAt?: StringWithAggregatesFilter<"WorkflowDebuggerOverlay"> | string
    copiedFromRunId?: StringNullableWithAggregatesFilter<"WorkflowDebuggerOverlay"> | string | null
    stateJson?: StringWithAggregatesFilter<"WorkflowDebuggerOverlay"> | string
  }

  export type WorkflowActivationWhereInput = {
    AND?: WorkflowActivationWhereInput | WorkflowActivationWhereInput[]
    OR?: WorkflowActivationWhereInput[]
    NOT?: WorkflowActivationWhereInput | WorkflowActivationWhereInput[]
    workflowId?: StringFilter<"WorkflowActivation"> | string
    isActive?: BoolFilter<"WorkflowActivation"> | boolean
    updatedAt?: StringFilter<"WorkflowActivation"> | string
  }

  export type WorkflowActivationOrderByWithRelationInput = {
    workflowId?: SortOrder
    isActive?: SortOrder
    updatedAt?: SortOrder
  }

  export type WorkflowActivationWhereUniqueInput = Prisma.AtLeast<{
    workflowId?: string
    AND?: WorkflowActivationWhereInput | WorkflowActivationWhereInput[]
    OR?: WorkflowActivationWhereInput[]
    NOT?: WorkflowActivationWhereInput | WorkflowActivationWhereInput[]
    isActive?: BoolFilter<"WorkflowActivation"> | boolean
    updatedAt?: StringFilter<"WorkflowActivation"> | string
  }, "workflowId">

  export type WorkflowActivationOrderByWithAggregationInput = {
    workflowId?: SortOrder
    isActive?: SortOrder
    updatedAt?: SortOrder
    _count?: WorkflowActivationCountOrderByAggregateInput
    _max?: WorkflowActivationMaxOrderByAggregateInput
    _min?: WorkflowActivationMinOrderByAggregateInput
  }

  export type WorkflowActivationScalarWhereWithAggregatesInput = {
    AND?: WorkflowActivationScalarWhereWithAggregatesInput | WorkflowActivationScalarWhereWithAggregatesInput[]
    OR?: WorkflowActivationScalarWhereWithAggregatesInput[]
    NOT?: WorkflowActivationScalarWhereWithAggregatesInput | WorkflowActivationScalarWhereWithAggregatesInput[]
    workflowId?: StringWithAggregatesFilter<"WorkflowActivation"> | string
    isActive?: BoolWithAggregatesFilter<"WorkflowActivation"> | boolean
    updatedAt?: StringWithAggregatesFilter<"WorkflowActivation"> | string
  }

  export type TriggerSetupStateWhereInput = {
    AND?: TriggerSetupStateWhereInput | TriggerSetupStateWhereInput[]
    OR?: TriggerSetupStateWhereInput[]
    NOT?: TriggerSetupStateWhereInput | TriggerSetupStateWhereInput[]
    workflowId?: StringFilter<"TriggerSetupState"> | string
    nodeId?: StringFilter<"TriggerSetupState"> | string
    updatedAt?: StringFilter<"TriggerSetupState"> | string
    stateJson?: StringFilter<"TriggerSetupState"> | string
  }

  export type TriggerSetupStateOrderByWithRelationInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    updatedAt?: SortOrder
    stateJson?: SortOrder
  }

  export type TriggerSetupStateWhereUniqueInput = Prisma.AtLeast<{
    workflowId_nodeId?: TriggerSetupStateWorkflowIdNodeIdCompoundUniqueInput
    AND?: TriggerSetupStateWhereInput | TriggerSetupStateWhereInput[]
    OR?: TriggerSetupStateWhereInput[]
    NOT?: TriggerSetupStateWhereInput | TriggerSetupStateWhereInput[]
    workflowId?: StringFilter<"TriggerSetupState"> | string
    nodeId?: StringFilter<"TriggerSetupState"> | string
    updatedAt?: StringFilter<"TriggerSetupState"> | string
    stateJson?: StringFilter<"TriggerSetupState"> | string
  }, "workflowId_nodeId">

  export type TriggerSetupStateOrderByWithAggregationInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    updatedAt?: SortOrder
    stateJson?: SortOrder
    _count?: TriggerSetupStateCountOrderByAggregateInput
    _max?: TriggerSetupStateMaxOrderByAggregateInput
    _min?: TriggerSetupStateMinOrderByAggregateInput
  }

  export type TriggerSetupStateScalarWhereWithAggregatesInput = {
    AND?: TriggerSetupStateScalarWhereWithAggregatesInput | TriggerSetupStateScalarWhereWithAggregatesInput[]
    OR?: TriggerSetupStateScalarWhereWithAggregatesInput[]
    NOT?: TriggerSetupStateScalarWhereWithAggregatesInput | TriggerSetupStateScalarWhereWithAggregatesInput[]
    workflowId?: StringWithAggregatesFilter<"TriggerSetupState"> | string
    nodeId?: StringWithAggregatesFilter<"TriggerSetupState"> | string
    updatedAt?: StringWithAggregatesFilter<"TriggerSetupState"> | string
    stateJson?: StringWithAggregatesFilter<"TriggerSetupState"> | string
  }

  export type RunTraceContextWhereInput = {
    AND?: RunTraceContextWhereInput | RunTraceContextWhereInput[]
    OR?: RunTraceContextWhereInput[]
    NOT?: RunTraceContextWhereInput | RunTraceContextWhereInput[]
    runId?: StringFilter<"RunTraceContext"> | string
    workflowId?: StringFilter<"RunTraceContext"> | string
    traceId?: StringFilter<"RunTraceContext"> | string
    rootSpanId?: StringFilter<"RunTraceContext"> | string
    serviceName?: StringNullableFilter<"RunTraceContext"> | string | null
    createdAt?: StringFilter<"RunTraceContext"> | string
    expiresAt?: StringNullableFilter<"RunTraceContext"> | string | null
  }

  export type RunTraceContextOrderByWithRelationInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    traceId?: SortOrder
    rootSpanId?: SortOrder
    serviceName?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
  }

  export type RunTraceContextWhereUniqueInput = Prisma.AtLeast<{
    runId?: string
    traceId?: string
    AND?: RunTraceContextWhereInput | RunTraceContextWhereInput[]
    OR?: RunTraceContextWhereInput[]
    NOT?: RunTraceContextWhereInput | RunTraceContextWhereInput[]
    workflowId?: StringFilter<"RunTraceContext"> | string
    rootSpanId?: StringFilter<"RunTraceContext"> | string
    serviceName?: StringNullableFilter<"RunTraceContext"> | string | null
    createdAt?: StringFilter<"RunTraceContext"> | string
    expiresAt?: StringNullableFilter<"RunTraceContext"> | string | null
  }, "runId" | "traceId">

  export type RunTraceContextOrderByWithAggregationInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    traceId?: SortOrder
    rootSpanId?: SortOrder
    serviceName?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    _count?: RunTraceContextCountOrderByAggregateInput
    _max?: RunTraceContextMaxOrderByAggregateInput
    _min?: RunTraceContextMinOrderByAggregateInput
  }

  export type RunTraceContextScalarWhereWithAggregatesInput = {
    AND?: RunTraceContextScalarWhereWithAggregatesInput | RunTraceContextScalarWhereWithAggregatesInput[]
    OR?: RunTraceContextScalarWhereWithAggregatesInput[]
    NOT?: RunTraceContextScalarWhereWithAggregatesInput | RunTraceContextScalarWhereWithAggregatesInput[]
    runId?: StringWithAggregatesFilter<"RunTraceContext"> | string
    workflowId?: StringWithAggregatesFilter<"RunTraceContext"> | string
    traceId?: StringWithAggregatesFilter<"RunTraceContext"> | string
    rootSpanId?: StringWithAggregatesFilter<"RunTraceContext"> | string
    serviceName?: StringNullableWithAggregatesFilter<"RunTraceContext"> | string | null
    createdAt?: StringWithAggregatesFilter<"RunTraceContext"> | string
    expiresAt?: StringNullableWithAggregatesFilter<"RunTraceContext"> | string | null
  }

  export type TelemetrySpanWhereInput = {
    AND?: TelemetrySpanWhereInput | TelemetrySpanWhereInput[]
    OR?: TelemetrySpanWhereInput[]
    NOT?: TelemetrySpanWhereInput | TelemetrySpanWhereInput[]
    telemetrySpanId?: StringFilter<"TelemetrySpan"> | string
    traceId?: StringFilter<"TelemetrySpan"> | string
    spanId?: StringFilter<"TelemetrySpan"> | string
    parentSpanId?: StringNullableFilter<"TelemetrySpan"> | string | null
    runId?: StringFilter<"TelemetrySpan"> | string
    workflowId?: StringFilter<"TelemetrySpan"> | string
    nodeId?: StringNullableFilter<"TelemetrySpan"> | string | null
    activationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    connectionInvocationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    name?: StringFilter<"TelemetrySpan"> | string
    kind?: StringFilter<"TelemetrySpan"> | string
    status?: StringNullableFilter<"TelemetrySpan"> | string | null
    statusMessage?: StringNullableFilter<"TelemetrySpan"> | string | null
    startTime?: StringNullableFilter<"TelemetrySpan"> | string | null
    endTime?: StringNullableFilter<"TelemetrySpan"> | string | null
    workflowFolder?: StringNullableFilter<"TelemetrySpan"> | string | null
    nodeType?: StringNullableFilter<"TelemetrySpan"> | string | null
    nodeRole?: StringNullableFilter<"TelemetrySpan"> | string | null
    modelName?: StringNullableFilter<"TelemetrySpan"> | string | null
    attributesJson?: StringNullableFilter<"TelemetrySpan"> | string | null
    eventsJson?: StringNullableFilter<"TelemetrySpan"> | string | null
    retentionExpiresAt?: StringNullableFilter<"TelemetrySpan"> | string | null
    iterationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    itemIndex?: IntNullableFilter<"TelemetrySpan"> | number | null
    parentInvocationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    updatedAt?: StringFilter<"TelemetrySpan"> | string
  }

  export type TelemetrySpanOrderByWithRelationInput = {
    telemetrySpanId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    parentSpanId?: SortOrderInput | SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    connectionInvocationId?: SortOrderInput | SortOrder
    name?: SortOrder
    kind?: SortOrder
    status?: SortOrderInput | SortOrder
    statusMessage?: SortOrderInput | SortOrder
    startTime?: SortOrderInput | SortOrder
    endTime?: SortOrderInput | SortOrder
    workflowFolder?: SortOrderInput | SortOrder
    nodeType?: SortOrderInput | SortOrder
    nodeRole?: SortOrderInput | SortOrder
    modelName?: SortOrderInput | SortOrder
    attributesJson?: SortOrderInput | SortOrder
    eventsJson?: SortOrderInput | SortOrder
    retentionExpiresAt?: SortOrderInput | SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    parentInvocationId?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
  }

  export type TelemetrySpanWhereUniqueInput = Prisma.AtLeast<{
    telemetrySpanId?: string
    traceId_spanId?: TelemetrySpanTraceIdSpanIdCompoundUniqueInput
    AND?: TelemetrySpanWhereInput | TelemetrySpanWhereInput[]
    OR?: TelemetrySpanWhereInput[]
    NOT?: TelemetrySpanWhereInput | TelemetrySpanWhereInput[]
    traceId?: StringFilter<"TelemetrySpan"> | string
    spanId?: StringFilter<"TelemetrySpan"> | string
    parentSpanId?: StringNullableFilter<"TelemetrySpan"> | string | null
    runId?: StringFilter<"TelemetrySpan"> | string
    workflowId?: StringFilter<"TelemetrySpan"> | string
    nodeId?: StringNullableFilter<"TelemetrySpan"> | string | null
    activationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    connectionInvocationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    name?: StringFilter<"TelemetrySpan"> | string
    kind?: StringFilter<"TelemetrySpan"> | string
    status?: StringNullableFilter<"TelemetrySpan"> | string | null
    statusMessage?: StringNullableFilter<"TelemetrySpan"> | string | null
    startTime?: StringNullableFilter<"TelemetrySpan"> | string | null
    endTime?: StringNullableFilter<"TelemetrySpan"> | string | null
    workflowFolder?: StringNullableFilter<"TelemetrySpan"> | string | null
    nodeType?: StringNullableFilter<"TelemetrySpan"> | string | null
    nodeRole?: StringNullableFilter<"TelemetrySpan"> | string | null
    modelName?: StringNullableFilter<"TelemetrySpan"> | string | null
    attributesJson?: StringNullableFilter<"TelemetrySpan"> | string | null
    eventsJson?: StringNullableFilter<"TelemetrySpan"> | string | null
    retentionExpiresAt?: StringNullableFilter<"TelemetrySpan"> | string | null
    iterationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    itemIndex?: IntNullableFilter<"TelemetrySpan"> | number | null
    parentInvocationId?: StringNullableFilter<"TelemetrySpan"> | string | null
    updatedAt?: StringFilter<"TelemetrySpan"> | string
  }, "telemetrySpanId" | "traceId_spanId">

  export type TelemetrySpanOrderByWithAggregationInput = {
    telemetrySpanId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    parentSpanId?: SortOrderInput | SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    connectionInvocationId?: SortOrderInput | SortOrder
    name?: SortOrder
    kind?: SortOrder
    status?: SortOrderInput | SortOrder
    statusMessage?: SortOrderInput | SortOrder
    startTime?: SortOrderInput | SortOrder
    endTime?: SortOrderInput | SortOrder
    workflowFolder?: SortOrderInput | SortOrder
    nodeType?: SortOrderInput | SortOrder
    nodeRole?: SortOrderInput | SortOrder
    modelName?: SortOrderInput | SortOrder
    attributesJson?: SortOrderInput | SortOrder
    eventsJson?: SortOrderInput | SortOrder
    retentionExpiresAt?: SortOrderInput | SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    parentInvocationId?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    _count?: TelemetrySpanCountOrderByAggregateInput
    _avg?: TelemetrySpanAvgOrderByAggregateInput
    _max?: TelemetrySpanMaxOrderByAggregateInput
    _min?: TelemetrySpanMinOrderByAggregateInput
    _sum?: TelemetrySpanSumOrderByAggregateInput
  }

  export type TelemetrySpanScalarWhereWithAggregatesInput = {
    AND?: TelemetrySpanScalarWhereWithAggregatesInput | TelemetrySpanScalarWhereWithAggregatesInput[]
    OR?: TelemetrySpanScalarWhereWithAggregatesInput[]
    NOT?: TelemetrySpanScalarWhereWithAggregatesInput | TelemetrySpanScalarWhereWithAggregatesInput[]
    telemetrySpanId?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    traceId?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    spanId?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    parentSpanId?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    runId?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    workflowId?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    nodeId?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    activationId?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    connectionInvocationId?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    name?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    kind?: StringWithAggregatesFilter<"TelemetrySpan"> | string
    status?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    statusMessage?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    startTime?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    endTime?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    workflowFolder?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    nodeType?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    nodeRole?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    modelName?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    attributesJson?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    eventsJson?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    retentionExpiresAt?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    iterationId?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    itemIndex?: IntNullableWithAggregatesFilter<"TelemetrySpan"> | number | null
    parentInvocationId?: StringNullableWithAggregatesFilter<"TelemetrySpan"> | string | null
    updatedAt?: StringWithAggregatesFilter<"TelemetrySpan"> | string
  }

  export type WorkflowSnapshotWhereInput = {
    AND?: WorkflowSnapshotWhereInput | WorkflowSnapshotWhereInput[]
    OR?: WorkflowSnapshotWhereInput[]
    NOT?: WorkflowSnapshotWhereInput | WorkflowSnapshotWhereInput[]
    id?: StringFilter<"WorkflowSnapshot"> | string
    workflowId?: StringFilter<"WorkflowSnapshot"> | string
    snapshotHash?: StringFilter<"WorkflowSnapshot"> | string
    snapshotJson?: StringFilter<"WorkflowSnapshot"> | string
    createdAt?: StringFilter<"WorkflowSnapshot"> | string
    runs?: RunListRelationFilter
  }

  export type WorkflowSnapshotOrderByWithRelationInput = {
    id?: SortOrder
    workflowId?: SortOrder
    snapshotHash?: SortOrder
    snapshotJson?: SortOrder
    createdAt?: SortOrder
    runs?: RunOrderByRelationAggregateInput
  }

  export type WorkflowSnapshotWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    workflowId_snapshotHash?: WorkflowSnapshotWorkflowIdSnapshotHashCompoundUniqueInput
    AND?: WorkflowSnapshotWhereInput | WorkflowSnapshotWhereInput[]
    OR?: WorkflowSnapshotWhereInput[]
    NOT?: WorkflowSnapshotWhereInput | WorkflowSnapshotWhereInput[]
    workflowId?: StringFilter<"WorkflowSnapshot"> | string
    snapshotHash?: StringFilter<"WorkflowSnapshot"> | string
    snapshotJson?: StringFilter<"WorkflowSnapshot"> | string
    createdAt?: StringFilter<"WorkflowSnapshot"> | string
    runs?: RunListRelationFilter
  }, "id" | "workflowId_snapshotHash">

  export type WorkflowSnapshotOrderByWithAggregationInput = {
    id?: SortOrder
    workflowId?: SortOrder
    snapshotHash?: SortOrder
    snapshotJson?: SortOrder
    createdAt?: SortOrder
    _count?: WorkflowSnapshotCountOrderByAggregateInput
    _max?: WorkflowSnapshotMaxOrderByAggregateInput
    _min?: WorkflowSnapshotMinOrderByAggregateInput
  }

  export type WorkflowSnapshotScalarWhereWithAggregatesInput = {
    AND?: WorkflowSnapshotScalarWhereWithAggregatesInput | WorkflowSnapshotScalarWhereWithAggregatesInput[]
    OR?: WorkflowSnapshotScalarWhereWithAggregatesInput[]
    NOT?: WorkflowSnapshotScalarWhereWithAggregatesInput | WorkflowSnapshotScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WorkflowSnapshot"> | string
    workflowId?: StringWithAggregatesFilter<"WorkflowSnapshot"> | string
    snapshotHash?: StringWithAggregatesFilter<"WorkflowSnapshot"> | string
    snapshotJson?: StringWithAggregatesFilter<"WorkflowSnapshot"> | string
    createdAt?: StringWithAggregatesFilter<"WorkflowSnapshot"> | string
  }

  export type TelemetryArtifactWhereInput = {
    AND?: TelemetryArtifactWhereInput | TelemetryArtifactWhereInput[]
    OR?: TelemetryArtifactWhereInput[]
    NOT?: TelemetryArtifactWhereInput | TelemetryArtifactWhereInput[]
    artifactId?: StringFilter<"TelemetryArtifact"> | string
    traceId?: StringFilter<"TelemetryArtifact"> | string
    spanId?: StringFilter<"TelemetryArtifact"> | string
    runId?: StringFilter<"TelemetryArtifact"> | string
    workflowId?: StringFilter<"TelemetryArtifact"> | string
    nodeId?: StringNullableFilter<"TelemetryArtifact"> | string | null
    activationId?: StringNullableFilter<"TelemetryArtifact"> | string | null
    kind?: StringFilter<"TelemetryArtifact"> | string
    contentType?: StringFilter<"TelemetryArtifact"> | string
    previewText?: StringNullableFilter<"TelemetryArtifact"> | string | null
    previewJson?: StringNullableFilter<"TelemetryArtifact"> | string | null
    payloadText?: StringNullableFilter<"TelemetryArtifact"> | string | null
    payloadJson?: StringNullableFilter<"TelemetryArtifact"> | string | null
    payloadStorageKey?: StringNullableFilter<"TelemetryArtifact"> | string | null
    bytes?: IntNullableFilter<"TelemetryArtifact"> | number | null
    truncated?: BoolNullableFilter<"TelemetryArtifact"> | boolean | null
    createdAt?: StringFilter<"TelemetryArtifact"> | string
    expiresAt?: StringNullableFilter<"TelemetryArtifact"> | string | null
    retentionExpiresAt?: StringNullableFilter<"TelemetryArtifact"> | string | null
  }

  export type TelemetryArtifactOrderByWithRelationInput = {
    artifactId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    kind?: SortOrder
    contentType?: SortOrder
    previewText?: SortOrderInput | SortOrder
    previewJson?: SortOrderInput | SortOrder
    payloadText?: SortOrderInput | SortOrder
    payloadJson?: SortOrderInput | SortOrder
    payloadStorageKey?: SortOrderInput | SortOrder
    bytes?: SortOrderInput | SortOrder
    truncated?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    retentionExpiresAt?: SortOrderInput | SortOrder
  }

  export type TelemetryArtifactWhereUniqueInput = Prisma.AtLeast<{
    artifactId?: string
    AND?: TelemetryArtifactWhereInput | TelemetryArtifactWhereInput[]
    OR?: TelemetryArtifactWhereInput[]
    NOT?: TelemetryArtifactWhereInput | TelemetryArtifactWhereInput[]
    traceId?: StringFilter<"TelemetryArtifact"> | string
    spanId?: StringFilter<"TelemetryArtifact"> | string
    runId?: StringFilter<"TelemetryArtifact"> | string
    workflowId?: StringFilter<"TelemetryArtifact"> | string
    nodeId?: StringNullableFilter<"TelemetryArtifact"> | string | null
    activationId?: StringNullableFilter<"TelemetryArtifact"> | string | null
    kind?: StringFilter<"TelemetryArtifact"> | string
    contentType?: StringFilter<"TelemetryArtifact"> | string
    previewText?: StringNullableFilter<"TelemetryArtifact"> | string | null
    previewJson?: StringNullableFilter<"TelemetryArtifact"> | string | null
    payloadText?: StringNullableFilter<"TelemetryArtifact"> | string | null
    payloadJson?: StringNullableFilter<"TelemetryArtifact"> | string | null
    payloadStorageKey?: StringNullableFilter<"TelemetryArtifact"> | string | null
    bytes?: IntNullableFilter<"TelemetryArtifact"> | number | null
    truncated?: BoolNullableFilter<"TelemetryArtifact"> | boolean | null
    createdAt?: StringFilter<"TelemetryArtifact"> | string
    expiresAt?: StringNullableFilter<"TelemetryArtifact"> | string | null
    retentionExpiresAt?: StringNullableFilter<"TelemetryArtifact"> | string | null
  }, "artifactId">

  export type TelemetryArtifactOrderByWithAggregationInput = {
    artifactId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    kind?: SortOrder
    contentType?: SortOrder
    previewText?: SortOrderInput | SortOrder
    previewJson?: SortOrderInput | SortOrder
    payloadText?: SortOrderInput | SortOrder
    payloadJson?: SortOrderInput | SortOrder
    payloadStorageKey?: SortOrderInput | SortOrder
    bytes?: SortOrderInput | SortOrder
    truncated?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    retentionExpiresAt?: SortOrderInput | SortOrder
    _count?: TelemetryArtifactCountOrderByAggregateInput
    _avg?: TelemetryArtifactAvgOrderByAggregateInput
    _max?: TelemetryArtifactMaxOrderByAggregateInput
    _min?: TelemetryArtifactMinOrderByAggregateInput
    _sum?: TelemetryArtifactSumOrderByAggregateInput
  }

  export type TelemetryArtifactScalarWhereWithAggregatesInput = {
    AND?: TelemetryArtifactScalarWhereWithAggregatesInput | TelemetryArtifactScalarWhereWithAggregatesInput[]
    OR?: TelemetryArtifactScalarWhereWithAggregatesInput[]
    NOT?: TelemetryArtifactScalarWhereWithAggregatesInput | TelemetryArtifactScalarWhereWithAggregatesInput[]
    artifactId?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    traceId?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    spanId?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    runId?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    workflowId?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    nodeId?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    activationId?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    kind?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    contentType?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    previewText?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    previewJson?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    payloadText?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    payloadJson?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    payloadStorageKey?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    bytes?: IntNullableWithAggregatesFilter<"TelemetryArtifact"> | number | null
    truncated?: BoolNullableWithAggregatesFilter<"TelemetryArtifact"> | boolean | null
    createdAt?: StringWithAggregatesFilter<"TelemetryArtifact"> | string
    expiresAt?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
    retentionExpiresAt?: StringNullableWithAggregatesFilter<"TelemetryArtifact"> | string | null
  }

  export type TelemetryMetricPointWhereInput = {
    AND?: TelemetryMetricPointWhereInput | TelemetryMetricPointWhereInput[]
    OR?: TelemetryMetricPointWhereInput[]
    NOT?: TelemetryMetricPointWhereInput | TelemetryMetricPointWhereInput[]
    metricPointId?: StringFilter<"TelemetryMetricPoint"> | string
    traceId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    spanId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    runId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    workflowId?: StringFilter<"TelemetryMetricPoint"> | string
    nodeId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    activationId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    metricName?: StringFilter<"TelemetryMetricPoint"> | string
    value?: FloatFilter<"TelemetryMetricPoint"> | number
    unit?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    observedAt?: StringFilter<"TelemetryMetricPoint"> | string
    workflowFolder?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    nodeType?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    nodeRole?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    modelName?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    dimensionsJson?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    retentionExpiresAt?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    iterationId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    itemIndex?: IntNullableFilter<"TelemetryMetricPoint"> | number | null
    parentInvocationId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
  }

  export type TelemetryMetricPointOrderByWithRelationInput = {
    metricPointId?: SortOrder
    traceId?: SortOrderInput | SortOrder
    spanId?: SortOrderInput | SortOrder
    runId?: SortOrderInput | SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    metricName?: SortOrder
    value?: SortOrder
    unit?: SortOrderInput | SortOrder
    observedAt?: SortOrder
    workflowFolder?: SortOrderInput | SortOrder
    nodeType?: SortOrderInput | SortOrder
    nodeRole?: SortOrderInput | SortOrder
    modelName?: SortOrderInput | SortOrder
    dimensionsJson?: SortOrderInput | SortOrder
    retentionExpiresAt?: SortOrderInput | SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    parentInvocationId?: SortOrderInput | SortOrder
  }

  export type TelemetryMetricPointWhereUniqueInput = Prisma.AtLeast<{
    metricPointId?: string
    AND?: TelemetryMetricPointWhereInput | TelemetryMetricPointWhereInput[]
    OR?: TelemetryMetricPointWhereInput[]
    NOT?: TelemetryMetricPointWhereInput | TelemetryMetricPointWhereInput[]
    traceId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    spanId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    runId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    workflowId?: StringFilter<"TelemetryMetricPoint"> | string
    nodeId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    activationId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    metricName?: StringFilter<"TelemetryMetricPoint"> | string
    value?: FloatFilter<"TelemetryMetricPoint"> | number
    unit?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    observedAt?: StringFilter<"TelemetryMetricPoint"> | string
    workflowFolder?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    nodeType?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    nodeRole?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    modelName?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    dimensionsJson?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    retentionExpiresAt?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    iterationId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
    itemIndex?: IntNullableFilter<"TelemetryMetricPoint"> | number | null
    parentInvocationId?: StringNullableFilter<"TelemetryMetricPoint"> | string | null
  }, "metricPointId">

  export type TelemetryMetricPointOrderByWithAggregationInput = {
    metricPointId?: SortOrder
    traceId?: SortOrderInput | SortOrder
    spanId?: SortOrderInput | SortOrder
    runId?: SortOrderInput | SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrderInput | SortOrder
    activationId?: SortOrderInput | SortOrder
    metricName?: SortOrder
    value?: SortOrder
    unit?: SortOrderInput | SortOrder
    observedAt?: SortOrder
    workflowFolder?: SortOrderInput | SortOrder
    nodeType?: SortOrderInput | SortOrder
    nodeRole?: SortOrderInput | SortOrder
    modelName?: SortOrderInput | SortOrder
    dimensionsJson?: SortOrderInput | SortOrder
    retentionExpiresAt?: SortOrderInput | SortOrder
    iterationId?: SortOrderInput | SortOrder
    itemIndex?: SortOrderInput | SortOrder
    parentInvocationId?: SortOrderInput | SortOrder
    _count?: TelemetryMetricPointCountOrderByAggregateInput
    _avg?: TelemetryMetricPointAvgOrderByAggregateInput
    _max?: TelemetryMetricPointMaxOrderByAggregateInput
    _min?: TelemetryMetricPointMinOrderByAggregateInput
    _sum?: TelemetryMetricPointSumOrderByAggregateInput
  }

  export type TelemetryMetricPointScalarWhereWithAggregatesInput = {
    AND?: TelemetryMetricPointScalarWhereWithAggregatesInput | TelemetryMetricPointScalarWhereWithAggregatesInput[]
    OR?: TelemetryMetricPointScalarWhereWithAggregatesInput[]
    NOT?: TelemetryMetricPointScalarWhereWithAggregatesInput | TelemetryMetricPointScalarWhereWithAggregatesInput[]
    metricPointId?: StringWithAggregatesFilter<"TelemetryMetricPoint"> | string
    traceId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    spanId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    runId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    workflowId?: StringWithAggregatesFilter<"TelemetryMetricPoint"> | string
    nodeId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    activationId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    metricName?: StringWithAggregatesFilter<"TelemetryMetricPoint"> | string
    value?: FloatWithAggregatesFilter<"TelemetryMetricPoint"> | number
    unit?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    observedAt?: StringWithAggregatesFilter<"TelemetryMetricPoint"> | string
    workflowFolder?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    nodeType?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    nodeRole?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    modelName?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    dimensionsJson?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    retentionExpiresAt?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    iterationId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
    itemIndex?: IntNullableWithAggregatesFilter<"TelemetryMetricPoint"> | number | null
    parentInvocationId?: StringNullableWithAggregatesFilter<"TelemetryMetricPoint"> | string | null
  }

  export type CredentialInstanceWhereInput = {
    AND?: CredentialInstanceWhereInput | CredentialInstanceWhereInput[]
    OR?: CredentialInstanceWhereInput[]
    NOT?: CredentialInstanceWhereInput | CredentialInstanceWhereInput[]
    instanceId?: StringFilter<"CredentialInstance"> | string
    typeId?: StringFilter<"CredentialInstance"> | string
    displayName?: StringFilter<"CredentialInstance"> | string
    sourceKind?: StringFilter<"CredentialInstance"> | string
    publicConfigJson?: StringFilter<"CredentialInstance"> | string
    secretRefJson?: StringFilter<"CredentialInstance"> | string
    tagsJson?: StringFilter<"CredentialInstance"> | string
    setupStatus?: StringFilter<"CredentialInstance"> | string
    createdAt?: StringFilter<"CredentialInstance"> | string
    updatedAt?: StringFilter<"CredentialInstance"> | string
    materialSource?: StringFilter<"CredentialInstance"> | string
    materialRef?: StringFilter<"CredentialInstance"> | string
  }

  export type CredentialInstanceOrderByWithRelationInput = {
    instanceId?: SortOrder
    typeId?: SortOrder
    displayName?: SortOrder
    sourceKind?: SortOrder
    publicConfigJson?: SortOrder
    secretRefJson?: SortOrder
    tagsJson?: SortOrder
    setupStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    materialSource?: SortOrder
    materialRef?: SortOrder
  }

  export type CredentialInstanceWhereUniqueInput = Prisma.AtLeast<{
    instanceId?: string
    AND?: CredentialInstanceWhereInput | CredentialInstanceWhereInput[]
    OR?: CredentialInstanceWhereInput[]
    NOT?: CredentialInstanceWhereInput | CredentialInstanceWhereInput[]
    typeId?: StringFilter<"CredentialInstance"> | string
    displayName?: StringFilter<"CredentialInstance"> | string
    sourceKind?: StringFilter<"CredentialInstance"> | string
    publicConfigJson?: StringFilter<"CredentialInstance"> | string
    secretRefJson?: StringFilter<"CredentialInstance"> | string
    tagsJson?: StringFilter<"CredentialInstance"> | string
    setupStatus?: StringFilter<"CredentialInstance"> | string
    createdAt?: StringFilter<"CredentialInstance"> | string
    updatedAt?: StringFilter<"CredentialInstance"> | string
    materialSource?: StringFilter<"CredentialInstance"> | string
    materialRef?: StringFilter<"CredentialInstance"> | string
  }, "instanceId">

  export type CredentialInstanceOrderByWithAggregationInput = {
    instanceId?: SortOrder
    typeId?: SortOrder
    displayName?: SortOrder
    sourceKind?: SortOrder
    publicConfigJson?: SortOrder
    secretRefJson?: SortOrder
    tagsJson?: SortOrder
    setupStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    materialSource?: SortOrder
    materialRef?: SortOrder
    _count?: CredentialInstanceCountOrderByAggregateInput
    _max?: CredentialInstanceMaxOrderByAggregateInput
    _min?: CredentialInstanceMinOrderByAggregateInput
  }

  export type CredentialInstanceScalarWhereWithAggregatesInput = {
    AND?: CredentialInstanceScalarWhereWithAggregatesInput | CredentialInstanceScalarWhereWithAggregatesInput[]
    OR?: CredentialInstanceScalarWhereWithAggregatesInput[]
    NOT?: CredentialInstanceScalarWhereWithAggregatesInput | CredentialInstanceScalarWhereWithAggregatesInput[]
    instanceId?: StringWithAggregatesFilter<"CredentialInstance"> | string
    typeId?: StringWithAggregatesFilter<"CredentialInstance"> | string
    displayName?: StringWithAggregatesFilter<"CredentialInstance"> | string
    sourceKind?: StringWithAggregatesFilter<"CredentialInstance"> | string
    publicConfigJson?: StringWithAggregatesFilter<"CredentialInstance"> | string
    secretRefJson?: StringWithAggregatesFilter<"CredentialInstance"> | string
    tagsJson?: StringWithAggregatesFilter<"CredentialInstance"> | string
    setupStatus?: StringWithAggregatesFilter<"CredentialInstance"> | string
    createdAt?: StringWithAggregatesFilter<"CredentialInstance"> | string
    updatedAt?: StringWithAggregatesFilter<"CredentialInstance"> | string
    materialSource?: StringWithAggregatesFilter<"CredentialInstance"> | string
    materialRef?: StringWithAggregatesFilter<"CredentialInstance"> | string
  }

  export type CredentialSecretMaterialWhereInput = {
    AND?: CredentialSecretMaterialWhereInput | CredentialSecretMaterialWhereInput[]
    OR?: CredentialSecretMaterialWhereInput[]
    NOT?: CredentialSecretMaterialWhereInput | CredentialSecretMaterialWhereInput[]
    instanceId?: StringFilter<"CredentialSecretMaterial"> | string
    encryptedJson?: StringFilter<"CredentialSecretMaterial"> | string
    encryptionKeyId?: StringFilter<"CredentialSecretMaterial"> | string
    schemaVersion?: IntFilter<"CredentialSecretMaterial"> | number
    updatedAt?: StringFilter<"CredentialSecretMaterial"> | string
  }

  export type CredentialSecretMaterialOrderByWithRelationInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialSecretMaterialWhereUniqueInput = Prisma.AtLeast<{
    instanceId?: string
    AND?: CredentialSecretMaterialWhereInput | CredentialSecretMaterialWhereInput[]
    OR?: CredentialSecretMaterialWhereInput[]
    NOT?: CredentialSecretMaterialWhereInput | CredentialSecretMaterialWhereInput[]
    encryptedJson?: StringFilter<"CredentialSecretMaterial"> | string
    encryptionKeyId?: StringFilter<"CredentialSecretMaterial"> | string
    schemaVersion?: IntFilter<"CredentialSecretMaterial"> | number
    updatedAt?: StringFilter<"CredentialSecretMaterial"> | string
  }, "instanceId">

  export type CredentialSecretMaterialOrderByWithAggregationInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    updatedAt?: SortOrder
    _count?: CredentialSecretMaterialCountOrderByAggregateInput
    _avg?: CredentialSecretMaterialAvgOrderByAggregateInput
    _max?: CredentialSecretMaterialMaxOrderByAggregateInput
    _min?: CredentialSecretMaterialMinOrderByAggregateInput
    _sum?: CredentialSecretMaterialSumOrderByAggregateInput
  }

  export type CredentialSecretMaterialScalarWhereWithAggregatesInput = {
    AND?: CredentialSecretMaterialScalarWhereWithAggregatesInput | CredentialSecretMaterialScalarWhereWithAggregatesInput[]
    OR?: CredentialSecretMaterialScalarWhereWithAggregatesInput[]
    NOT?: CredentialSecretMaterialScalarWhereWithAggregatesInput | CredentialSecretMaterialScalarWhereWithAggregatesInput[]
    instanceId?: StringWithAggregatesFilter<"CredentialSecretMaterial"> | string
    encryptedJson?: StringWithAggregatesFilter<"CredentialSecretMaterial"> | string
    encryptionKeyId?: StringWithAggregatesFilter<"CredentialSecretMaterial"> | string
    schemaVersion?: IntWithAggregatesFilter<"CredentialSecretMaterial"> | number
    updatedAt?: StringWithAggregatesFilter<"CredentialSecretMaterial"> | string
  }

  export type CredentialOAuth2MaterialWhereInput = {
    AND?: CredentialOAuth2MaterialWhereInput | CredentialOAuth2MaterialWhereInput[]
    OR?: CredentialOAuth2MaterialWhereInput[]
    NOT?: CredentialOAuth2MaterialWhereInput | CredentialOAuth2MaterialWhereInput[]
    instanceId?: StringFilter<"CredentialOAuth2Material"> | string
    encryptedJson?: StringFilter<"CredentialOAuth2Material"> | string
    encryptionKeyId?: StringFilter<"CredentialOAuth2Material"> | string
    schemaVersion?: IntFilter<"CredentialOAuth2Material"> | number
    providerId?: StringFilter<"CredentialOAuth2Material"> | string
    connectedEmail?: StringNullableFilter<"CredentialOAuth2Material"> | string | null
    connectedAt?: StringNullableFilter<"CredentialOAuth2Material"> | string | null
    scopesJson?: StringFilter<"CredentialOAuth2Material"> | string
    updatedAt?: StringFilter<"CredentialOAuth2Material"> | string
  }

  export type CredentialOAuth2MaterialOrderByWithRelationInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    providerId?: SortOrder
    connectedEmail?: SortOrderInput | SortOrder
    connectedAt?: SortOrderInput | SortOrder
    scopesJson?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialOAuth2MaterialWhereUniqueInput = Prisma.AtLeast<{
    instanceId?: string
    AND?: CredentialOAuth2MaterialWhereInput | CredentialOAuth2MaterialWhereInput[]
    OR?: CredentialOAuth2MaterialWhereInput[]
    NOT?: CredentialOAuth2MaterialWhereInput | CredentialOAuth2MaterialWhereInput[]
    encryptedJson?: StringFilter<"CredentialOAuth2Material"> | string
    encryptionKeyId?: StringFilter<"CredentialOAuth2Material"> | string
    schemaVersion?: IntFilter<"CredentialOAuth2Material"> | number
    providerId?: StringFilter<"CredentialOAuth2Material"> | string
    connectedEmail?: StringNullableFilter<"CredentialOAuth2Material"> | string | null
    connectedAt?: StringNullableFilter<"CredentialOAuth2Material"> | string | null
    scopesJson?: StringFilter<"CredentialOAuth2Material"> | string
    updatedAt?: StringFilter<"CredentialOAuth2Material"> | string
  }, "instanceId">

  export type CredentialOAuth2MaterialOrderByWithAggregationInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    providerId?: SortOrder
    connectedEmail?: SortOrderInput | SortOrder
    connectedAt?: SortOrderInput | SortOrder
    scopesJson?: SortOrder
    updatedAt?: SortOrder
    _count?: CredentialOAuth2MaterialCountOrderByAggregateInput
    _avg?: CredentialOAuth2MaterialAvgOrderByAggregateInput
    _max?: CredentialOAuth2MaterialMaxOrderByAggregateInput
    _min?: CredentialOAuth2MaterialMinOrderByAggregateInput
    _sum?: CredentialOAuth2MaterialSumOrderByAggregateInput
  }

  export type CredentialOAuth2MaterialScalarWhereWithAggregatesInput = {
    AND?: CredentialOAuth2MaterialScalarWhereWithAggregatesInput | CredentialOAuth2MaterialScalarWhereWithAggregatesInput[]
    OR?: CredentialOAuth2MaterialScalarWhereWithAggregatesInput[]
    NOT?: CredentialOAuth2MaterialScalarWhereWithAggregatesInput | CredentialOAuth2MaterialScalarWhereWithAggregatesInput[]
    instanceId?: StringWithAggregatesFilter<"CredentialOAuth2Material"> | string
    encryptedJson?: StringWithAggregatesFilter<"CredentialOAuth2Material"> | string
    encryptionKeyId?: StringWithAggregatesFilter<"CredentialOAuth2Material"> | string
    schemaVersion?: IntWithAggregatesFilter<"CredentialOAuth2Material"> | number
    providerId?: StringWithAggregatesFilter<"CredentialOAuth2Material"> | string
    connectedEmail?: StringNullableWithAggregatesFilter<"CredentialOAuth2Material"> | string | null
    connectedAt?: StringNullableWithAggregatesFilter<"CredentialOAuth2Material"> | string | null
    scopesJson?: StringWithAggregatesFilter<"CredentialOAuth2Material"> | string
    updatedAt?: StringWithAggregatesFilter<"CredentialOAuth2Material"> | string
  }

  export type CredentialOAuth2StateWhereInput = {
    AND?: CredentialOAuth2StateWhereInput | CredentialOAuth2StateWhereInput[]
    OR?: CredentialOAuth2StateWhereInput[]
    NOT?: CredentialOAuth2StateWhereInput | CredentialOAuth2StateWhereInput[]
    state?: StringFilter<"CredentialOAuth2State"> | string
    instanceId?: StringFilter<"CredentialOAuth2State"> | string
    codeVerifier?: StringNullableFilter<"CredentialOAuth2State"> | string | null
    providerId?: StringNullableFilter<"CredentialOAuth2State"> | string | null
    requestedScopesJson?: StringFilter<"CredentialOAuth2State"> | string
    createdAt?: StringFilter<"CredentialOAuth2State"> | string
    expiresAt?: StringFilter<"CredentialOAuth2State"> | string
  }

  export type CredentialOAuth2StateOrderByWithRelationInput = {
    state?: SortOrder
    instanceId?: SortOrder
    codeVerifier?: SortOrderInput | SortOrder
    providerId?: SortOrderInput | SortOrder
    requestedScopesJson?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type CredentialOAuth2StateWhereUniqueInput = Prisma.AtLeast<{
    state?: string
    AND?: CredentialOAuth2StateWhereInput | CredentialOAuth2StateWhereInput[]
    OR?: CredentialOAuth2StateWhereInput[]
    NOT?: CredentialOAuth2StateWhereInput | CredentialOAuth2StateWhereInput[]
    instanceId?: StringFilter<"CredentialOAuth2State"> | string
    codeVerifier?: StringNullableFilter<"CredentialOAuth2State"> | string | null
    providerId?: StringNullableFilter<"CredentialOAuth2State"> | string | null
    requestedScopesJson?: StringFilter<"CredentialOAuth2State"> | string
    createdAt?: StringFilter<"CredentialOAuth2State"> | string
    expiresAt?: StringFilter<"CredentialOAuth2State"> | string
  }, "state">

  export type CredentialOAuth2StateOrderByWithAggregationInput = {
    state?: SortOrder
    instanceId?: SortOrder
    codeVerifier?: SortOrderInput | SortOrder
    providerId?: SortOrderInput | SortOrder
    requestedScopesJson?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    _count?: CredentialOAuth2StateCountOrderByAggregateInput
    _max?: CredentialOAuth2StateMaxOrderByAggregateInput
    _min?: CredentialOAuth2StateMinOrderByAggregateInput
  }

  export type CredentialOAuth2StateScalarWhereWithAggregatesInput = {
    AND?: CredentialOAuth2StateScalarWhereWithAggregatesInput | CredentialOAuth2StateScalarWhereWithAggregatesInput[]
    OR?: CredentialOAuth2StateScalarWhereWithAggregatesInput[]
    NOT?: CredentialOAuth2StateScalarWhereWithAggregatesInput | CredentialOAuth2StateScalarWhereWithAggregatesInput[]
    state?: StringWithAggregatesFilter<"CredentialOAuth2State"> | string
    instanceId?: StringWithAggregatesFilter<"CredentialOAuth2State"> | string
    codeVerifier?: StringNullableWithAggregatesFilter<"CredentialOAuth2State"> | string | null
    providerId?: StringNullableWithAggregatesFilter<"CredentialOAuth2State"> | string | null
    requestedScopesJson?: StringWithAggregatesFilter<"CredentialOAuth2State"> | string
    createdAt?: StringWithAggregatesFilter<"CredentialOAuth2State"> | string
    expiresAt?: StringWithAggregatesFilter<"CredentialOAuth2State"> | string
  }

  export type CredentialBindingWhereInput = {
    AND?: CredentialBindingWhereInput | CredentialBindingWhereInput[]
    OR?: CredentialBindingWhereInput[]
    NOT?: CredentialBindingWhereInput | CredentialBindingWhereInput[]
    workflowId?: StringFilter<"CredentialBinding"> | string
    nodeId?: StringFilter<"CredentialBinding"> | string
    slotKey?: StringFilter<"CredentialBinding"> | string
    instanceId?: StringFilter<"CredentialBinding"> | string
    updatedAt?: StringFilter<"CredentialBinding"> | string
  }

  export type CredentialBindingOrderByWithRelationInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    slotKey?: SortOrder
    instanceId?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialBindingWhereUniqueInput = Prisma.AtLeast<{
    workflowId_nodeId_slotKey?: CredentialBindingWorkflowIdNodeIdSlotKeyCompoundUniqueInput
    AND?: CredentialBindingWhereInput | CredentialBindingWhereInput[]
    OR?: CredentialBindingWhereInput[]
    NOT?: CredentialBindingWhereInput | CredentialBindingWhereInput[]
    workflowId?: StringFilter<"CredentialBinding"> | string
    nodeId?: StringFilter<"CredentialBinding"> | string
    slotKey?: StringFilter<"CredentialBinding"> | string
    instanceId?: StringFilter<"CredentialBinding"> | string
    updatedAt?: StringFilter<"CredentialBinding"> | string
  }, "workflowId_nodeId_slotKey">

  export type CredentialBindingOrderByWithAggregationInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    slotKey?: SortOrder
    instanceId?: SortOrder
    updatedAt?: SortOrder
    _count?: CredentialBindingCountOrderByAggregateInput
    _max?: CredentialBindingMaxOrderByAggregateInput
    _min?: CredentialBindingMinOrderByAggregateInput
  }

  export type CredentialBindingScalarWhereWithAggregatesInput = {
    AND?: CredentialBindingScalarWhereWithAggregatesInput | CredentialBindingScalarWhereWithAggregatesInput[]
    OR?: CredentialBindingScalarWhereWithAggregatesInput[]
    NOT?: CredentialBindingScalarWhereWithAggregatesInput | CredentialBindingScalarWhereWithAggregatesInput[]
    workflowId?: StringWithAggregatesFilter<"CredentialBinding"> | string
    nodeId?: StringWithAggregatesFilter<"CredentialBinding"> | string
    slotKey?: StringWithAggregatesFilter<"CredentialBinding"> | string
    instanceId?: StringWithAggregatesFilter<"CredentialBinding"> | string
    updatedAt?: StringWithAggregatesFilter<"CredentialBinding"> | string
  }

  export type CredentialTestResultWhereInput = {
    AND?: CredentialTestResultWhereInput | CredentialTestResultWhereInput[]
    OR?: CredentialTestResultWhereInput[]
    NOT?: CredentialTestResultWhereInput | CredentialTestResultWhereInput[]
    testId?: StringFilter<"CredentialTestResult"> | string
    instanceId?: StringFilter<"CredentialTestResult"> | string
    status?: StringFilter<"CredentialTestResult"> | string
    message?: StringNullableFilter<"CredentialTestResult"> | string | null
    detailsJson?: StringFilter<"CredentialTestResult"> | string
    testedAt?: StringFilter<"CredentialTestResult"> | string
    expiresAt?: StringNullableFilter<"CredentialTestResult"> | string | null
  }

  export type CredentialTestResultOrderByWithRelationInput = {
    testId?: SortOrder
    instanceId?: SortOrder
    status?: SortOrder
    message?: SortOrderInput | SortOrder
    detailsJson?: SortOrder
    testedAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
  }

  export type CredentialTestResultWhereUniqueInput = Prisma.AtLeast<{
    testId?: string
    AND?: CredentialTestResultWhereInput | CredentialTestResultWhereInput[]
    OR?: CredentialTestResultWhereInput[]
    NOT?: CredentialTestResultWhereInput | CredentialTestResultWhereInput[]
    instanceId?: StringFilter<"CredentialTestResult"> | string
    status?: StringFilter<"CredentialTestResult"> | string
    message?: StringNullableFilter<"CredentialTestResult"> | string | null
    detailsJson?: StringFilter<"CredentialTestResult"> | string
    testedAt?: StringFilter<"CredentialTestResult"> | string
    expiresAt?: StringNullableFilter<"CredentialTestResult"> | string | null
  }, "testId">

  export type CredentialTestResultOrderByWithAggregationInput = {
    testId?: SortOrder
    instanceId?: SortOrder
    status?: SortOrder
    message?: SortOrderInput | SortOrder
    detailsJson?: SortOrder
    testedAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    _count?: CredentialTestResultCountOrderByAggregateInput
    _max?: CredentialTestResultMaxOrderByAggregateInput
    _min?: CredentialTestResultMinOrderByAggregateInput
  }

  export type CredentialTestResultScalarWhereWithAggregatesInput = {
    AND?: CredentialTestResultScalarWhereWithAggregatesInput | CredentialTestResultScalarWhereWithAggregatesInput[]
    OR?: CredentialTestResultScalarWhereWithAggregatesInput[]
    NOT?: CredentialTestResultScalarWhereWithAggregatesInput | CredentialTestResultScalarWhereWithAggregatesInput[]
    testId?: StringWithAggregatesFilter<"CredentialTestResult"> | string
    instanceId?: StringWithAggregatesFilter<"CredentialTestResult"> | string
    status?: StringWithAggregatesFilter<"CredentialTestResult"> | string
    message?: StringNullableWithAggregatesFilter<"CredentialTestResult"> | string | null
    detailsJson?: StringWithAggregatesFilter<"CredentialTestResult"> | string
    testedAt?: StringWithAggregatesFilter<"CredentialTestResult"> | string
    expiresAt?: StringNullableWithAggregatesFilter<"CredentialTestResult"> | string | null
  }

  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    name?: StringNullableFilter<"User"> | string | null
    email?: StringNullableFilter<"User"> | string | null
    emailVerified?: BoolFilter<"User"> | boolean
    image?: StringNullableFilter<"User"> | string | null
    passwordHash?: StringNullableFilter<"User"> | string | null
    accountStatus?: StringFilter<"User"> | string
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    accounts?: AccountListRelationFilter
    sessions?: SessionListRelationFilter
    invites?: UserInviteListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    emailVerified?: SortOrder
    image?: SortOrderInput | SortOrder
    passwordHash?: SortOrderInput | SortOrder
    accountStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    accounts?: AccountOrderByRelationAggregateInput
    sessions?: SessionOrderByRelationAggregateInput
    invites?: UserInviteOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    name?: StringNullableFilter<"User"> | string | null
    emailVerified?: BoolFilter<"User"> | boolean
    image?: StringNullableFilter<"User"> | string | null
    passwordHash?: StringNullableFilter<"User"> | string | null
    accountStatus?: StringFilter<"User"> | string
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    accounts?: AccountListRelationFilter
    sessions?: SessionListRelationFilter
    invites?: UserInviteListRelationFilter
  }, "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    emailVerified?: SortOrder
    image?: SortOrderInput | SortOrder
    passwordHash?: SortOrderInput | SortOrder
    accountStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    name?: StringNullableWithAggregatesFilter<"User"> | string | null
    email?: StringNullableWithAggregatesFilter<"User"> | string | null
    emailVerified?: BoolWithAggregatesFilter<"User"> | boolean
    image?: StringNullableWithAggregatesFilter<"User"> | string | null
    passwordHash?: StringNullableWithAggregatesFilter<"User"> | string | null
    accountStatus?: StringWithAggregatesFilter<"User"> | string
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type UserInviteWhereInput = {
    AND?: UserInviteWhereInput | UserInviteWhereInput[]
    OR?: UserInviteWhereInput[]
    NOT?: UserInviteWhereInput | UserInviteWhereInput[]
    id?: StringFilter<"UserInvite"> | string
    userId?: StringFilter<"UserInvite"> | string
    tokenHash?: StringFilter<"UserInvite"> | string
    expiresAt?: DateTimeFilter<"UserInvite"> | Date | string
    createdAt?: DateTimeFilter<"UserInvite"> | Date | string
    revokedAt?: DateTimeNullableFilter<"UserInvite"> | Date | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type UserInviteOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type UserInviteWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    tokenHash?: string
    AND?: UserInviteWhereInput | UserInviteWhereInput[]
    OR?: UserInviteWhereInput[]
    NOT?: UserInviteWhereInput | UserInviteWhereInput[]
    userId?: StringFilter<"UserInvite"> | string
    expiresAt?: DateTimeFilter<"UserInvite"> | Date | string
    createdAt?: DateTimeFilter<"UserInvite"> | Date | string
    revokedAt?: DateTimeNullableFilter<"UserInvite"> | Date | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "tokenHash">

  export type UserInviteOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrderInput | SortOrder
    _count?: UserInviteCountOrderByAggregateInput
    _max?: UserInviteMaxOrderByAggregateInput
    _min?: UserInviteMinOrderByAggregateInput
  }

  export type UserInviteScalarWhereWithAggregatesInput = {
    AND?: UserInviteScalarWhereWithAggregatesInput | UserInviteScalarWhereWithAggregatesInput[]
    OR?: UserInviteScalarWhereWithAggregatesInput[]
    NOT?: UserInviteScalarWhereWithAggregatesInput | UserInviteScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UserInvite"> | string
    userId?: StringWithAggregatesFilter<"UserInvite"> | string
    tokenHash?: StringWithAggregatesFilter<"UserInvite"> | string
    expiresAt?: DateTimeWithAggregatesFilter<"UserInvite"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"UserInvite"> | Date | string
    revokedAt?: DateTimeNullableWithAggregatesFilter<"UserInvite"> | Date | string | null
  }

  export type AccountWhereInput = {
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    id?: StringFilter<"Account"> | string
    userId?: StringFilter<"Account"> | string
    type?: StringFilter<"Account"> | string
    provider?: StringFilter<"Account"> | string
    providerAccountId?: StringFilter<"Account"> | string
    password?: StringNullableFilter<"Account"> | string | null
    refresh_token?: StringNullableFilter<"Account"> | string | null
    access_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    accessTokenExpiresAt?: DateTimeNullableFilter<"Account"> | Date | string | null
    refreshTokenExpiresAt?: DateTimeNullableFilter<"Account"> | Date | string | null
    token_type?: StringNullableFilter<"Account"> | string | null
    scope?: StringNullableFilter<"Account"> | string | null
    id_token?: StringNullableFilter<"Account"> | string | null
    session_state?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AccountOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    password?: SortOrderInput | SortOrder
    refresh_token?: SortOrderInput | SortOrder
    access_token?: SortOrderInput | SortOrder
    expires_at?: SortOrderInput | SortOrder
    accessTokenExpiresAt?: SortOrderInput | SortOrder
    refreshTokenExpiresAt?: SortOrderInput | SortOrder
    token_type?: SortOrderInput | SortOrder
    scope?: SortOrderInput | SortOrder
    id_token?: SortOrderInput | SortOrder
    session_state?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type AccountWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    provider_providerAccountId?: AccountProviderProviderAccountIdCompoundUniqueInput
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    userId?: StringFilter<"Account"> | string
    type?: StringFilter<"Account"> | string
    provider?: StringFilter<"Account"> | string
    providerAccountId?: StringFilter<"Account"> | string
    password?: StringNullableFilter<"Account"> | string | null
    refresh_token?: StringNullableFilter<"Account"> | string | null
    access_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    accessTokenExpiresAt?: DateTimeNullableFilter<"Account"> | Date | string | null
    refreshTokenExpiresAt?: DateTimeNullableFilter<"Account"> | Date | string | null
    token_type?: StringNullableFilter<"Account"> | string | null
    scope?: StringNullableFilter<"Account"> | string | null
    id_token?: StringNullableFilter<"Account"> | string | null
    session_state?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "provider_providerAccountId">

  export type AccountOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    password?: SortOrderInput | SortOrder
    refresh_token?: SortOrderInput | SortOrder
    access_token?: SortOrderInput | SortOrder
    expires_at?: SortOrderInput | SortOrder
    accessTokenExpiresAt?: SortOrderInput | SortOrder
    refreshTokenExpiresAt?: SortOrderInput | SortOrder
    token_type?: SortOrderInput | SortOrder
    scope?: SortOrderInput | SortOrder
    id_token?: SortOrderInput | SortOrder
    session_state?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: AccountCountOrderByAggregateInput
    _avg?: AccountAvgOrderByAggregateInput
    _max?: AccountMaxOrderByAggregateInput
    _min?: AccountMinOrderByAggregateInput
    _sum?: AccountSumOrderByAggregateInput
  }

  export type AccountScalarWhereWithAggregatesInput = {
    AND?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    OR?: AccountScalarWhereWithAggregatesInput[]
    NOT?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Account"> | string
    userId?: StringWithAggregatesFilter<"Account"> | string
    type?: StringWithAggregatesFilter<"Account"> | string
    provider?: StringWithAggregatesFilter<"Account"> | string
    providerAccountId?: StringWithAggregatesFilter<"Account"> | string
    password?: StringNullableWithAggregatesFilter<"Account"> | string | null
    refresh_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    access_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    expires_at?: IntNullableWithAggregatesFilter<"Account"> | number | null
    accessTokenExpiresAt?: DateTimeNullableWithAggregatesFilter<"Account"> | Date | string | null
    refreshTokenExpiresAt?: DateTimeNullableWithAggregatesFilter<"Account"> | Date | string | null
    token_type?: StringNullableWithAggregatesFilter<"Account"> | string | null
    scope?: StringNullableWithAggregatesFilter<"Account"> | string | null
    id_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    session_state?: StringNullableWithAggregatesFilter<"Account"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
  }

  export type SessionWhereInput = {
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    id?: StringFilter<"Session"> | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    ipAddress?: StringNullableFilter<"Session"> | string | null
    userAgent?: StringNullableFilter<"Session"> | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type SessionOrderByWithRelationInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    sessionToken?: string
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    ipAddress?: StringNullableFilter<"Session"> | string | null
    userAgent?: StringNullableFilter<"Session"> | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "sessionToken">

  export type SessionOrderByWithAggregationInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    _count?: SessionCountOrderByAggregateInput
    _max?: SessionMaxOrderByAggregateInput
    _min?: SessionMinOrderByAggregateInput
  }

  export type SessionScalarWhereWithAggregatesInput = {
    AND?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    OR?: SessionScalarWhereWithAggregatesInput[]
    NOT?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Session"> | string
    sessionToken?: StringWithAggregatesFilter<"Session"> | string
    userId?: StringWithAggregatesFilter<"Session"> | string
    expires?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    ipAddress?: StringNullableWithAggregatesFilter<"Session"> | string | null
    userAgent?: StringNullableWithAggregatesFilter<"Session"> | string | null
  }

  export type VerificationTokenWhereInput = {
    AND?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
    OR?: VerificationTokenWhereInput[]
    NOT?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
    id?: StringFilter<"VerificationToken"> | string
    identifier?: StringFilter<"VerificationToken"> | string
    token?: StringFilter<"VerificationToken"> | string
    expires?: DateTimeFilter<"VerificationToken"> | Date | string
    createdAt?: DateTimeFilter<"VerificationToken"> | Date | string
    updatedAt?: DateTimeFilter<"VerificationToken"> | Date | string
  }

  export type VerificationTokenOrderByWithRelationInput = {
    id?: SortOrder
    identifier?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type VerificationTokenWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    identifier_token?: VerificationTokenIdentifierTokenCompoundUniqueInput
    AND?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
    OR?: VerificationTokenWhereInput[]
    NOT?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
    identifier?: StringFilter<"VerificationToken"> | string
    token?: StringFilter<"VerificationToken"> | string
    expires?: DateTimeFilter<"VerificationToken"> | Date | string
    createdAt?: DateTimeFilter<"VerificationToken"> | Date | string
    updatedAt?: DateTimeFilter<"VerificationToken"> | Date | string
  }, "id" | "identifier_token">

  export type VerificationTokenOrderByWithAggregationInput = {
    id?: SortOrder
    identifier?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: VerificationTokenCountOrderByAggregateInput
    _max?: VerificationTokenMaxOrderByAggregateInput
    _min?: VerificationTokenMinOrderByAggregateInput
  }

  export type VerificationTokenScalarWhereWithAggregatesInput = {
    AND?: VerificationTokenScalarWhereWithAggregatesInput | VerificationTokenScalarWhereWithAggregatesInput[]
    OR?: VerificationTokenScalarWhereWithAggregatesInput[]
    NOT?: VerificationTokenScalarWhereWithAggregatesInput | VerificationTokenScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"VerificationToken"> | string
    identifier?: StringWithAggregatesFilter<"VerificationToken"> | string
    token?: StringWithAggregatesFilter<"VerificationToken"> | string
    expires?: DateTimeWithAggregatesFilter<"VerificationToken"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"VerificationToken"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"VerificationToken"> | Date | string
  }

  export type WorkflowAuditLogWhereInput = {
    AND?: WorkflowAuditLogWhereInput | WorkflowAuditLogWhereInput[]
    OR?: WorkflowAuditLogWhereInput[]
    NOT?: WorkflowAuditLogWhereInput | WorkflowAuditLogWhereInput[]
    id?: StringFilter<"WorkflowAuditLog"> | string
    occurredAt?: DateTimeFilter<"WorkflowAuditLog"> | Date | string
    actorUserId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    actorSessionId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    action?: StringFilter<"WorkflowAuditLog"> | string
    resourceType?: StringFilter<"WorkflowAuditLog"> | string
    resourceId?: StringFilter<"WorkflowAuditLog"> | string
    outcome?: StringFilter<"WorkflowAuditLog"> | string
    errorCode?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    correlationId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    workflowId?: StringFilter<"WorkflowAuditLog"> | string
    runId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    nodeId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
  }

  export type WorkflowAuditLogOrderByWithRelationInput = {
    id?: SortOrder
    occurredAt?: SortOrder
    actorUserId?: SortOrderInput | SortOrder
    actorSessionId?: SortOrderInput | SortOrder
    action?: SortOrder
    resourceType?: SortOrder
    resourceId?: SortOrder
    outcome?: SortOrder
    errorCode?: SortOrderInput | SortOrder
    correlationId?: SortOrderInput | SortOrder
    workflowId?: SortOrder
    runId?: SortOrderInput | SortOrder
    nodeId?: SortOrderInput | SortOrder
  }

  export type WorkflowAuditLogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: WorkflowAuditLogWhereInput | WorkflowAuditLogWhereInput[]
    OR?: WorkflowAuditLogWhereInput[]
    NOT?: WorkflowAuditLogWhereInput | WorkflowAuditLogWhereInput[]
    occurredAt?: DateTimeFilter<"WorkflowAuditLog"> | Date | string
    actorUserId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    actorSessionId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    action?: StringFilter<"WorkflowAuditLog"> | string
    resourceType?: StringFilter<"WorkflowAuditLog"> | string
    resourceId?: StringFilter<"WorkflowAuditLog"> | string
    outcome?: StringFilter<"WorkflowAuditLog"> | string
    errorCode?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    correlationId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    workflowId?: StringFilter<"WorkflowAuditLog"> | string
    runId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
    nodeId?: StringNullableFilter<"WorkflowAuditLog"> | string | null
  }, "id">

  export type WorkflowAuditLogOrderByWithAggregationInput = {
    id?: SortOrder
    occurredAt?: SortOrder
    actorUserId?: SortOrderInput | SortOrder
    actorSessionId?: SortOrderInput | SortOrder
    action?: SortOrder
    resourceType?: SortOrder
    resourceId?: SortOrder
    outcome?: SortOrder
    errorCode?: SortOrderInput | SortOrder
    correlationId?: SortOrderInput | SortOrder
    workflowId?: SortOrder
    runId?: SortOrderInput | SortOrder
    nodeId?: SortOrderInput | SortOrder
    _count?: WorkflowAuditLogCountOrderByAggregateInput
    _max?: WorkflowAuditLogMaxOrderByAggregateInput
    _min?: WorkflowAuditLogMinOrderByAggregateInput
  }

  export type WorkflowAuditLogScalarWhereWithAggregatesInput = {
    AND?: WorkflowAuditLogScalarWhereWithAggregatesInput | WorkflowAuditLogScalarWhereWithAggregatesInput[]
    OR?: WorkflowAuditLogScalarWhereWithAggregatesInput[]
    NOT?: WorkflowAuditLogScalarWhereWithAggregatesInput | WorkflowAuditLogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WorkflowAuditLog"> | string
    occurredAt?: DateTimeWithAggregatesFilter<"WorkflowAuditLog"> | Date | string
    actorUserId?: StringNullableWithAggregatesFilter<"WorkflowAuditLog"> | string | null
    actorSessionId?: StringNullableWithAggregatesFilter<"WorkflowAuditLog"> | string | null
    action?: StringWithAggregatesFilter<"WorkflowAuditLog"> | string
    resourceType?: StringWithAggregatesFilter<"WorkflowAuditLog"> | string
    resourceId?: StringWithAggregatesFilter<"WorkflowAuditLog"> | string
    outcome?: StringWithAggregatesFilter<"WorkflowAuditLog"> | string
    errorCode?: StringNullableWithAggregatesFilter<"WorkflowAuditLog"> | string | null
    correlationId?: StringNullableWithAggregatesFilter<"WorkflowAuditLog"> | string | null
    workflowId?: StringWithAggregatesFilter<"WorkflowAuditLog"> | string
    runId?: StringNullableWithAggregatesFilter<"WorkflowAuditLog"> | string | null
    nodeId?: StringNullableWithAggregatesFilter<"WorkflowAuditLog"> | string | null
  }

  export type HmacNonceWhereInput = {
    AND?: HmacNonceWhereInput | HmacNonceWhereInput[]
    OR?: HmacNonceWhereInput[]
    NOT?: HmacNonceWhereInput | HmacNonceWhereInput[]
    nonce?: StringFilter<"HmacNonce"> | string
    expiresAt?: DateTimeFilter<"HmacNonce"> | Date | string
  }

  export type HmacNonceOrderByWithRelationInput = {
    nonce?: SortOrder
    expiresAt?: SortOrder
  }

  export type HmacNonceWhereUniqueInput = Prisma.AtLeast<{
    nonce?: string
    AND?: HmacNonceWhereInput | HmacNonceWhereInput[]
    OR?: HmacNonceWhereInput[]
    NOT?: HmacNonceWhereInput | HmacNonceWhereInput[]
    expiresAt?: DateTimeFilter<"HmacNonce"> | Date | string
  }, "nonce">

  export type HmacNonceOrderByWithAggregationInput = {
    nonce?: SortOrder
    expiresAt?: SortOrder
    _count?: HmacNonceCountOrderByAggregateInput
    _max?: HmacNonceMaxOrderByAggregateInput
    _min?: HmacNonceMinOrderByAggregateInput
  }

  export type HmacNonceScalarWhereWithAggregatesInput = {
    AND?: HmacNonceScalarWhereWithAggregatesInput | HmacNonceScalarWhereWithAggregatesInput[]
    OR?: HmacNonceScalarWhereWithAggregatesInput[]
    NOT?: HmacNonceScalarWhereWithAggregatesInput | HmacNonceScalarWhereWithAggregatesInput[]
    nonce?: StringWithAggregatesFilter<"HmacNonce"> | string
    expiresAt?: DateTimeWithAggregatesFilter<"HmacNonce"> | Date | string
  }

  export type HumanTaskWhereInput = {
    AND?: HumanTaskWhereInput | HumanTaskWhereInput[]
    OR?: HumanTaskWhereInput[]
    NOT?: HumanTaskWhereInput | HumanTaskWhereInput[]
    id?: StringFilter<"HumanTask"> | string
    runId?: StringFilter<"HumanTask"> | string
    workflowId?: StringFilter<"HumanTask"> | string
    workspaceId?: StringNullableFilter<"HumanTask"> | string | null
    nodeId?: StringFilter<"HumanTask"> | string
    activationId?: StringFilter<"HumanTask"> | string
    itemIndex?: IntFilter<"HumanTask"> | number
    status?: StringFilter<"HumanTask"> | string
    channel?: StringFilter<"HumanTask"> | string
    subjectJson?: StringFilter<"HumanTask"> | string
    metadataJson?: StringFilter<"HumanTask"> | string
    decisionSchemaJson?: StringFilter<"HumanTask"> | string
    decisionSchemaHash?: StringFilter<"HumanTask"> | string
    onTimeout?: StringFilter<"HumanTask"> | string
    deliveryRefJson?: StringNullableFilter<"HumanTask"> | string | null
    decisionJson?: StringNullableFilter<"HumanTask"> | string | null
    decidedAt?: DateTimeNullableFilter<"HumanTask"> | Date | string | null
    decidedByJson?: StringNullableFilter<"HumanTask"> | string | null
    resumeTokenHash?: StringFilter<"HumanTask"> | string
    expiresAt?: DateTimeFilter<"HumanTask"> | Date | string
    createdAt?: DateTimeFilter<"HumanTask"> | Date | string
  }

  export type HumanTaskOrderByWithRelationInput = {
    id?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    workspaceId?: SortOrderInput | SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    itemIndex?: SortOrder
    status?: SortOrder
    channel?: SortOrder
    subjectJson?: SortOrder
    metadataJson?: SortOrder
    decisionSchemaJson?: SortOrder
    decisionSchemaHash?: SortOrder
    onTimeout?: SortOrder
    deliveryRefJson?: SortOrderInput | SortOrder
    decisionJson?: SortOrderInput | SortOrder
    decidedAt?: SortOrderInput | SortOrder
    decidedByJson?: SortOrderInput | SortOrder
    resumeTokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
  }

  export type HumanTaskWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: HumanTaskWhereInput | HumanTaskWhereInput[]
    OR?: HumanTaskWhereInput[]
    NOT?: HumanTaskWhereInput | HumanTaskWhereInput[]
    runId?: StringFilter<"HumanTask"> | string
    workflowId?: StringFilter<"HumanTask"> | string
    workspaceId?: StringNullableFilter<"HumanTask"> | string | null
    nodeId?: StringFilter<"HumanTask"> | string
    activationId?: StringFilter<"HumanTask"> | string
    itemIndex?: IntFilter<"HumanTask"> | number
    status?: StringFilter<"HumanTask"> | string
    channel?: StringFilter<"HumanTask"> | string
    subjectJson?: StringFilter<"HumanTask"> | string
    metadataJson?: StringFilter<"HumanTask"> | string
    decisionSchemaJson?: StringFilter<"HumanTask"> | string
    decisionSchemaHash?: StringFilter<"HumanTask"> | string
    onTimeout?: StringFilter<"HumanTask"> | string
    deliveryRefJson?: StringNullableFilter<"HumanTask"> | string | null
    decisionJson?: StringNullableFilter<"HumanTask"> | string | null
    decidedAt?: DateTimeNullableFilter<"HumanTask"> | Date | string | null
    decidedByJson?: StringNullableFilter<"HumanTask"> | string | null
    resumeTokenHash?: StringFilter<"HumanTask"> | string
    expiresAt?: DateTimeFilter<"HumanTask"> | Date | string
    createdAt?: DateTimeFilter<"HumanTask"> | Date | string
  }, "id">

  export type HumanTaskOrderByWithAggregationInput = {
    id?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    workspaceId?: SortOrderInput | SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    itemIndex?: SortOrder
    status?: SortOrder
    channel?: SortOrder
    subjectJson?: SortOrder
    metadataJson?: SortOrder
    decisionSchemaJson?: SortOrder
    decisionSchemaHash?: SortOrder
    onTimeout?: SortOrder
    deliveryRefJson?: SortOrderInput | SortOrder
    decisionJson?: SortOrderInput | SortOrder
    decidedAt?: SortOrderInput | SortOrder
    decidedByJson?: SortOrderInput | SortOrder
    resumeTokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
    _count?: HumanTaskCountOrderByAggregateInput
    _avg?: HumanTaskAvgOrderByAggregateInput
    _max?: HumanTaskMaxOrderByAggregateInput
    _min?: HumanTaskMinOrderByAggregateInput
    _sum?: HumanTaskSumOrderByAggregateInput
  }

  export type HumanTaskScalarWhereWithAggregatesInput = {
    AND?: HumanTaskScalarWhereWithAggregatesInput | HumanTaskScalarWhereWithAggregatesInput[]
    OR?: HumanTaskScalarWhereWithAggregatesInput[]
    NOT?: HumanTaskScalarWhereWithAggregatesInput | HumanTaskScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"HumanTask"> | string
    runId?: StringWithAggregatesFilter<"HumanTask"> | string
    workflowId?: StringWithAggregatesFilter<"HumanTask"> | string
    workspaceId?: StringNullableWithAggregatesFilter<"HumanTask"> | string | null
    nodeId?: StringWithAggregatesFilter<"HumanTask"> | string
    activationId?: StringWithAggregatesFilter<"HumanTask"> | string
    itemIndex?: IntWithAggregatesFilter<"HumanTask"> | number
    status?: StringWithAggregatesFilter<"HumanTask"> | string
    channel?: StringWithAggregatesFilter<"HumanTask"> | string
    subjectJson?: StringWithAggregatesFilter<"HumanTask"> | string
    metadataJson?: StringWithAggregatesFilter<"HumanTask"> | string
    decisionSchemaJson?: StringWithAggregatesFilter<"HumanTask"> | string
    decisionSchemaHash?: StringWithAggregatesFilter<"HumanTask"> | string
    onTimeout?: StringWithAggregatesFilter<"HumanTask"> | string
    deliveryRefJson?: StringNullableWithAggregatesFilter<"HumanTask"> | string | null
    decisionJson?: StringNullableWithAggregatesFilter<"HumanTask"> | string | null
    decidedAt?: DateTimeNullableWithAggregatesFilter<"HumanTask"> | Date | string | null
    decidedByJson?: StringNullableWithAggregatesFilter<"HumanTask"> | string | null
    resumeTokenHash?: StringWithAggregatesFilter<"HumanTask"> | string
    expiresAt?: DateTimeWithAggregatesFilter<"HumanTask"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"HumanTask"> | Date | string
  }

  export type RunCreateInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionCreateNestedOneWithoutRunInput
    testSuiteRun?: TestSuiteRunCreateNestedOneWithoutRunsInput
    testAssertions?: TestAssertionCreateNestedManyWithoutRunInput
    workflowSnapshot?: WorkflowSnapshotCreateNestedOneWithoutRunsInput
  }

  export type RunUncheckedCreateInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemUncheckedCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput
    testAssertions?: TestAssertionUncheckedCreateNestedManyWithoutRunInput
  }

  export type RunUpdateInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUpdateOneWithoutRunNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneWithoutRunsNestedInput
    testAssertions?: TestAssertionUpdateManyWithoutRunNestedInput
    workflowSnapshot?: WorkflowSnapshotUpdateOneWithoutRunsNestedInput
  }

  export type RunUncheckedUpdateInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUncheckedUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput
    testAssertions?: TestAssertionUncheckedUpdateManyWithoutRunNestedInput
  }

  export type RunCreateManyInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
  }

  export type RunUpdateManyMutationInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunUncheckedUpdateManyInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunWorkItemCreateInput = {
    workItemId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName?: string | null
    claimToken?: string | null
    claimedBy?: string | null
    claimedAt?: string | null
    availableAt: string
    enqueuedAt: string
    completedAt?: string | null
    failedAt?: string | null
    sourceInstanceId?: string | null
    parentInstanceId?: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson?: string | null
    run: RunCreateNestedOneWithoutWorkItemsInput
  }

  export type RunWorkItemUncheckedCreateInput = {
    workItemId: string
    runId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName?: string | null
    claimToken?: string | null
    claimedBy?: string | null
    claimedAt?: string | null
    availableAt: string
    enqueuedAt: string
    completedAt?: string | null
    failedAt?: string | null
    sourceInstanceId?: string | null
    parentInstanceId?: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson?: string | null
  }

  export type RunWorkItemUpdateInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    run?: RunUpdateOneRequiredWithoutWorkItemsNestedInput
  }

  export type RunWorkItemUncheckedUpdateInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunWorkItemCreateManyInput = {
    workItemId: string
    runId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName?: string | null
    claimToken?: string | null
    claimedBy?: string | null
    claimedAt?: string | null
    availableAt: string
    enqueuedAt: string
    completedAt?: string | null
    failedAt?: string | null
    sourceInstanceId?: string | null
    parentInstanceId?: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson?: string | null
  }

  export type RunWorkItemUpdateManyMutationInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunWorkItemUncheckedUpdateManyInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExecutionInstanceCreateInput = {
    instanceId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind?: string | null
    activationId?: string | null
    batchId: string
    runIndex: number
    parentInstanceId?: string | null
    parentRunId?: string | null
    workerClaimToken?: string | null
    status: string
    queuedAt?: string | null
    startedAt?: string | null
    finishedAt?: string | null
    updatedAt: string
    itemCount: number
    inputJson?: string | null
    outputJson?: string | null
    errorJson?: string | null
    inputItemIndicesJson?: string | null
    outputItemCount?: number | null
    successfulItemCount?: number | null
    failedItemCount?: number | null
    inputStorageKind?: string | null
    outputStorageKind?: string | null
    inputBytes?: number | null
    outputBytes?: number | null
    inputPreviewJson?: string | null
    outputPreviewJson?: string | null
    inputPayloadRef?: string | null
    outputPayloadRef?: string | null
    inputTruncated?: boolean | null
    outputTruncated?: boolean | null
    usedPinnedOutput?: boolean | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    childRunId?: string | null
    run: RunCreateNestedOneWithoutExecutionInstancesInput
  }

  export type ExecutionInstanceUncheckedCreateInput = {
    instanceId: string
    runId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind?: string | null
    activationId?: string | null
    batchId: string
    runIndex: number
    parentInstanceId?: string | null
    parentRunId?: string | null
    workerClaimToken?: string | null
    status: string
    queuedAt?: string | null
    startedAt?: string | null
    finishedAt?: string | null
    updatedAt: string
    itemCount: number
    inputJson?: string | null
    outputJson?: string | null
    errorJson?: string | null
    inputItemIndicesJson?: string | null
    outputItemCount?: number | null
    successfulItemCount?: number | null
    failedItemCount?: number | null
    inputStorageKind?: string | null
    outputStorageKind?: string | null
    inputBytes?: number | null
    outputBytes?: number | null
    inputPreviewJson?: string | null
    outputPreviewJson?: string | null
    inputPayloadRef?: string | null
    outputPayloadRef?: string | null
    inputTruncated?: boolean | null
    outputTruncated?: boolean | null
    usedPinnedOutput?: boolean | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    childRunId?: string | null
  }

  export type ExecutionInstanceUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
    run?: RunUpdateOneRequiredWithoutExecutionInstancesNestedInput
  }

  export type ExecutionInstanceUncheckedUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExecutionInstanceCreateManyInput = {
    instanceId: string
    runId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind?: string | null
    activationId?: string | null
    batchId: string
    runIndex: number
    parentInstanceId?: string | null
    parentRunId?: string | null
    workerClaimToken?: string | null
    status: string
    queuedAt?: string | null
    startedAt?: string | null
    finishedAt?: string | null
    updatedAt: string
    itemCount: number
    inputJson?: string | null
    outputJson?: string | null
    errorJson?: string | null
    inputItemIndicesJson?: string | null
    outputItemCount?: number | null
    successfulItemCount?: number | null
    failedItemCount?: number | null
    inputStorageKind?: string | null
    outputStorageKind?: string | null
    inputBytes?: number | null
    outputBytes?: number | null
    inputPreviewJson?: string | null
    outputPreviewJson?: string | null
    inputPayloadRef?: string | null
    outputPayloadRef?: string | null
    inputTruncated?: boolean | null
    outputTruncated?: boolean | null
    usedPinnedOutput?: boolean | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    childRunId?: string | null
  }

  export type ExecutionInstanceUpdateManyMutationInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExecutionInstanceUncheckedUpdateManyInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunSlotProjectionCreateInput = {
    workflowId: string
    revision: number
    updatedAt: string
    slotStatesJson: string
    run: RunCreateNestedOneWithoutSlotProjectionInput
  }

  export type RunSlotProjectionUncheckedCreateInput = {
    runId: string
    workflowId: string
    revision: number
    updatedAt: string
    slotStatesJson: string
  }

  export type RunSlotProjectionUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
    slotStatesJson?: StringFieldUpdateOperationsInput | string
    run?: RunUpdateOneRequiredWithoutSlotProjectionNestedInput
  }

  export type RunSlotProjectionUncheckedUpdateInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
    slotStatesJson?: StringFieldUpdateOperationsInput | string
  }

  export type RunSlotProjectionCreateManyInput = {
    runId: string
    workflowId: string
    revision: number
    updatedAt: string
    slotStatesJson: string
  }

  export type RunSlotProjectionUpdateManyMutationInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
    slotStatesJson?: StringFieldUpdateOperationsInput | string
  }

  export type RunSlotProjectionUncheckedUpdateManyInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
    slotStatesJson?: StringFieldUpdateOperationsInput | string
  }

  export type TestSuiteRunCreateInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
    runs?: RunCreateNestedManyWithoutTestSuiteRunInput
    assertions?: TestAssertionCreateNestedManyWithoutTestSuiteRunInput
  }

  export type TestSuiteRunUncheckedCreateInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
    runs?: RunUncheckedCreateNestedManyWithoutTestSuiteRunInput
    assertions?: TestAssertionUncheckedCreateNestedManyWithoutTestSuiteRunInput
  }

  export type TestSuiteRunUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    runs?: RunUpdateManyWithoutTestSuiteRunNestedInput
    assertions?: TestAssertionUpdateManyWithoutTestSuiteRunNestedInput
  }

  export type TestSuiteRunUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    runs?: RunUncheckedUpdateManyWithoutTestSuiteRunNestedInput
    assertions?: TestAssertionUncheckedUpdateManyWithoutTestSuiteRunNestedInput
  }

  export type TestSuiteRunCreateManyInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
  }

  export type TestSuiteRunUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type TestSuiteRunUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type TestAssertionCreateInput = {
    id: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
    run: RunCreateNestedOneWithoutTestAssertionsInput
    testSuiteRun: TestSuiteRunCreateNestedOneWithoutAssertionsInput
  }

  export type TestAssertionUncheckedCreateInput = {
    id: string
    runId: string
    testSuiteRunId: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
  }

  export type TestAssertionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    run?: RunUpdateOneRequiredWithoutTestAssertionsNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneRequiredWithoutAssertionsNestedInput
  }

  export type TestAssertionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type TestAssertionCreateManyInput = {
    id: string
    runId: string
    testSuiteRunId: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
  }

  export type TestAssertionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type TestAssertionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowDebuggerOverlayCreateInput = {
    workflowId: string
    updatedAt: string
    copiedFromRunId?: string | null
    stateJson: string
  }

  export type WorkflowDebuggerOverlayUncheckedCreateInput = {
    workflowId: string
    updatedAt: string
    copiedFromRunId?: string | null
    stateJson: string
  }

  export type WorkflowDebuggerOverlayUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    copiedFromRunId?: NullableStringFieldUpdateOperationsInput | string | null
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowDebuggerOverlayUncheckedUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    copiedFromRunId?: NullableStringFieldUpdateOperationsInput | string | null
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowDebuggerOverlayCreateManyInput = {
    workflowId: string
    updatedAt: string
    copiedFromRunId?: string | null
    stateJson: string
  }

  export type WorkflowDebuggerOverlayUpdateManyMutationInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    copiedFromRunId?: NullableStringFieldUpdateOperationsInput | string | null
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowDebuggerOverlayUncheckedUpdateManyInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    copiedFromRunId?: NullableStringFieldUpdateOperationsInput | string | null
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowActivationCreateInput = {
    workflowId: string
    isActive?: boolean
    updatedAt: string
  }

  export type WorkflowActivationUncheckedCreateInput = {
    workflowId: string
    isActive?: boolean
    updatedAt: string
  }

  export type WorkflowActivationUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowActivationUncheckedUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowActivationCreateManyInput = {
    workflowId: string
    isActive?: boolean
    updatedAt: string
  }

  export type WorkflowActivationUpdateManyMutationInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowActivationUncheckedUpdateManyInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type TriggerSetupStateCreateInput = {
    workflowId: string
    nodeId: string
    updatedAt: string
    stateJson: string
  }

  export type TriggerSetupStateUncheckedCreateInput = {
    workflowId: string
    nodeId: string
    updatedAt: string
    stateJson: string
  }

  export type TriggerSetupStateUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type TriggerSetupStateUncheckedUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type TriggerSetupStateCreateManyInput = {
    workflowId: string
    nodeId: string
    updatedAt: string
    stateJson: string
  }

  export type TriggerSetupStateUpdateManyMutationInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type TriggerSetupStateUncheckedUpdateManyInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    stateJson?: StringFieldUpdateOperationsInput | string
  }

  export type RunTraceContextCreateInput = {
    runId: string
    workflowId: string
    traceId: string
    rootSpanId: string
    serviceName?: string | null
    createdAt: string
    expiresAt?: string | null
  }

  export type RunTraceContextUncheckedCreateInput = {
    runId: string
    workflowId: string
    traceId: string
    rootSpanId: string
    serviceName?: string | null
    createdAt: string
    expiresAt?: string | null
  }

  export type RunTraceContextUpdateInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    rootSpanId?: StringFieldUpdateOperationsInput | string
    serviceName?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunTraceContextUncheckedUpdateInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    rootSpanId?: StringFieldUpdateOperationsInput | string
    serviceName?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunTraceContextCreateManyInput = {
    runId: string
    workflowId: string
    traceId: string
    rootSpanId: string
    serviceName?: string | null
    createdAt: string
    expiresAt?: string | null
  }

  export type RunTraceContextUpdateManyMutationInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    rootSpanId?: StringFieldUpdateOperationsInput | string
    serviceName?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunTraceContextUncheckedUpdateManyInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    rootSpanId?: StringFieldUpdateOperationsInput | string
    serviceName?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetrySpanCreateInput = {
    telemetrySpanId: string
    traceId: string
    spanId: string
    parentSpanId?: string | null
    runId: string
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    connectionInvocationId?: string | null
    name: string
    kind: string
    status?: string | null
    statusMessage?: string | null
    startTime?: string | null
    endTime?: string | null
    workflowFolder?: string | null
    nodeType?: string | null
    nodeRole?: string | null
    modelName?: string | null
    attributesJson?: string | null
    eventsJson?: string | null
    retentionExpiresAt?: string | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    updatedAt: string
  }

  export type TelemetrySpanUncheckedCreateInput = {
    telemetrySpanId: string
    traceId: string
    spanId: string
    parentSpanId?: string | null
    runId: string
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    connectionInvocationId?: string | null
    name: string
    kind: string
    status?: string | null
    statusMessage?: string | null
    startTime?: string | null
    endTime?: string | null
    workflowFolder?: string | null
    nodeType?: string | null
    nodeRole?: string | null
    modelName?: string | null
    attributesJson?: string | null
    eventsJson?: string | null
    retentionExpiresAt?: string | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    updatedAt: string
  }

  export type TelemetrySpanUpdateInput = {
    telemetrySpanId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    parentSpanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    connectionInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    statusMessage?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: NullableStringFieldUpdateOperationsInput | string | null
    endTime?: NullableStringFieldUpdateOperationsInput | string | null
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    attributesJson?: NullableStringFieldUpdateOperationsInput | string | null
    eventsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type TelemetrySpanUncheckedUpdateInput = {
    telemetrySpanId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    parentSpanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    connectionInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    statusMessage?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: NullableStringFieldUpdateOperationsInput | string | null
    endTime?: NullableStringFieldUpdateOperationsInput | string | null
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    attributesJson?: NullableStringFieldUpdateOperationsInput | string | null
    eventsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type TelemetrySpanCreateManyInput = {
    telemetrySpanId: string
    traceId: string
    spanId: string
    parentSpanId?: string | null
    runId: string
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    connectionInvocationId?: string | null
    name: string
    kind: string
    status?: string | null
    statusMessage?: string | null
    startTime?: string | null
    endTime?: string | null
    workflowFolder?: string | null
    nodeType?: string | null
    nodeRole?: string | null
    modelName?: string | null
    attributesJson?: string | null
    eventsJson?: string | null
    retentionExpiresAt?: string | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    updatedAt: string
  }

  export type TelemetrySpanUpdateManyMutationInput = {
    telemetrySpanId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    parentSpanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    connectionInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    statusMessage?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: NullableStringFieldUpdateOperationsInput | string | null
    endTime?: NullableStringFieldUpdateOperationsInput | string | null
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    attributesJson?: NullableStringFieldUpdateOperationsInput | string | null
    eventsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type TelemetrySpanUncheckedUpdateManyInput = {
    telemetrySpanId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    parentSpanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    connectionInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    status?: NullableStringFieldUpdateOperationsInput | string | null
    statusMessage?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: NullableStringFieldUpdateOperationsInput | string | null
    endTime?: NullableStringFieldUpdateOperationsInput | string | null
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    attributesJson?: NullableStringFieldUpdateOperationsInput | string | null
    eventsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowSnapshotCreateInput = {
    id: string
    workflowId: string
    snapshotHash: string
    snapshotJson: string
    createdAt: string
    runs?: RunCreateNestedManyWithoutWorkflowSnapshotInput
  }

  export type WorkflowSnapshotUncheckedCreateInput = {
    id: string
    workflowId: string
    snapshotHash: string
    snapshotJson: string
    createdAt: string
    runs?: RunUncheckedCreateNestedManyWithoutWorkflowSnapshotInput
  }

  export type WorkflowSnapshotUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    snapshotHash?: StringFieldUpdateOperationsInput | string
    snapshotJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    runs?: RunUpdateManyWithoutWorkflowSnapshotNestedInput
  }

  export type WorkflowSnapshotUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    snapshotHash?: StringFieldUpdateOperationsInput | string
    snapshotJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    runs?: RunUncheckedUpdateManyWithoutWorkflowSnapshotNestedInput
  }

  export type WorkflowSnapshotCreateManyInput = {
    id: string
    workflowId: string
    snapshotHash: string
    snapshotJson: string
    createdAt: string
  }

  export type WorkflowSnapshotUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    snapshotHash?: StringFieldUpdateOperationsInput | string
    snapshotJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowSnapshotUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    snapshotHash?: StringFieldUpdateOperationsInput | string
    snapshotJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type TelemetryArtifactCreateInput = {
    artifactId: string
    traceId: string
    spanId: string
    runId: string
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    kind: string
    contentType: string
    previewText?: string | null
    previewJson?: string | null
    payloadText?: string | null
    payloadJson?: string | null
    payloadStorageKey?: string | null
    bytes?: number | null
    truncated?: boolean | null
    createdAt: string
    expiresAt?: string | null
    retentionExpiresAt?: string | null
  }

  export type TelemetryArtifactUncheckedCreateInput = {
    artifactId: string
    traceId: string
    spanId: string
    runId: string
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    kind: string
    contentType: string
    previewText?: string | null
    previewJson?: string | null
    payloadText?: string | null
    payloadJson?: string | null
    payloadStorageKey?: string | null
    bytes?: number | null
    truncated?: boolean | null
    createdAt: string
    expiresAt?: string | null
    retentionExpiresAt?: string | null
  }

  export type TelemetryArtifactUpdateInput = {
    artifactId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: StringFieldUpdateOperationsInput | string
    contentType?: StringFieldUpdateOperationsInput | string
    previewText?: NullableStringFieldUpdateOperationsInput | string | null
    previewJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadText?: NullableStringFieldUpdateOperationsInput | string | null
    payloadJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadStorageKey?: NullableStringFieldUpdateOperationsInput | string | null
    bytes?: NullableIntFieldUpdateOperationsInput | number | null
    truncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryArtifactUncheckedUpdateInput = {
    artifactId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: StringFieldUpdateOperationsInput | string
    contentType?: StringFieldUpdateOperationsInput | string
    previewText?: NullableStringFieldUpdateOperationsInput | string | null
    previewJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadText?: NullableStringFieldUpdateOperationsInput | string | null
    payloadJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadStorageKey?: NullableStringFieldUpdateOperationsInput | string | null
    bytes?: NullableIntFieldUpdateOperationsInput | number | null
    truncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryArtifactCreateManyInput = {
    artifactId: string
    traceId: string
    spanId: string
    runId: string
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    kind: string
    contentType: string
    previewText?: string | null
    previewJson?: string | null
    payloadText?: string | null
    payloadJson?: string | null
    payloadStorageKey?: string | null
    bytes?: number | null
    truncated?: boolean | null
    createdAt: string
    expiresAt?: string | null
    retentionExpiresAt?: string | null
  }

  export type TelemetryArtifactUpdateManyMutationInput = {
    artifactId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: StringFieldUpdateOperationsInput | string
    contentType?: StringFieldUpdateOperationsInput | string
    previewText?: NullableStringFieldUpdateOperationsInput | string | null
    previewJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadText?: NullableStringFieldUpdateOperationsInput | string | null
    payloadJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadStorageKey?: NullableStringFieldUpdateOperationsInput | string | null
    bytes?: NullableIntFieldUpdateOperationsInput | number | null
    truncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryArtifactUncheckedUpdateManyInput = {
    artifactId?: StringFieldUpdateOperationsInput | string
    traceId?: StringFieldUpdateOperationsInput | string
    spanId?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: StringFieldUpdateOperationsInput | string
    contentType?: StringFieldUpdateOperationsInput | string
    previewText?: NullableStringFieldUpdateOperationsInput | string | null
    previewJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadText?: NullableStringFieldUpdateOperationsInput | string | null
    payloadJson?: NullableStringFieldUpdateOperationsInput | string | null
    payloadStorageKey?: NullableStringFieldUpdateOperationsInput | string | null
    bytes?: NullableIntFieldUpdateOperationsInput | number | null
    truncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryMetricPointCreateInput = {
    metricPointId: string
    traceId?: string | null
    spanId?: string | null
    runId?: string | null
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    metricName: string
    value: number
    unit?: string | null
    observedAt: string
    workflowFolder?: string | null
    nodeType?: string | null
    nodeRole?: string | null
    modelName?: string | null
    dimensionsJson?: string | null
    retentionExpiresAt?: string | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
  }

  export type TelemetryMetricPointUncheckedCreateInput = {
    metricPointId: string
    traceId?: string | null
    spanId?: string | null
    runId?: string | null
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    metricName: string
    value: number
    unit?: string | null
    observedAt: string
    workflowFolder?: string | null
    nodeType?: string | null
    nodeRole?: string | null
    modelName?: string | null
    dimensionsJson?: string | null
    retentionExpiresAt?: string | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
  }

  export type TelemetryMetricPointUpdateInput = {
    metricPointId?: StringFieldUpdateOperationsInput | string
    traceId?: NullableStringFieldUpdateOperationsInput | string | null
    spanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    metricName?: StringFieldUpdateOperationsInput | string
    value?: FloatFieldUpdateOperationsInput | number
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    observedAt?: StringFieldUpdateOperationsInput | string
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    dimensionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryMetricPointUncheckedUpdateInput = {
    metricPointId?: StringFieldUpdateOperationsInput | string
    traceId?: NullableStringFieldUpdateOperationsInput | string | null
    spanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    metricName?: StringFieldUpdateOperationsInput | string
    value?: FloatFieldUpdateOperationsInput | number
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    observedAt?: StringFieldUpdateOperationsInput | string
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    dimensionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryMetricPointCreateManyInput = {
    metricPointId: string
    traceId?: string | null
    spanId?: string | null
    runId?: string | null
    workflowId: string
    nodeId?: string | null
    activationId?: string | null
    metricName: string
    value: number
    unit?: string | null
    observedAt: string
    workflowFolder?: string | null
    nodeType?: string | null
    nodeRole?: string | null
    modelName?: string | null
    dimensionsJson?: string | null
    retentionExpiresAt?: string | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
  }

  export type TelemetryMetricPointUpdateManyMutationInput = {
    metricPointId?: StringFieldUpdateOperationsInput | string
    traceId?: NullableStringFieldUpdateOperationsInput | string | null
    spanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    metricName?: StringFieldUpdateOperationsInput | string
    value?: FloatFieldUpdateOperationsInput | number
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    observedAt?: StringFieldUpdateOperationsInput | string
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    dimensionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TelemetryMetricPointUncheckedUpdateManyInput = {
    metricPointId?: StringFieldUpdateOperationsInput | string
    traceId?: NullableStringFieldUpdateOperationsInput | string | null
    spanId?: NullableStringFieldUpdateOperationsInput | string | null
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    metricName?: StringFieldUpdateOperationsInput | string
    value?: FloatFieldUpdateOperationsInput | number
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    observedAt?: StringFieldUpdateOperationsInput | string
    workflowFolder?: NullableStringFieldUpdateOperationsInput | string | null
    nodeType?: NullableStringFieldUpdateOperationsInput | string | null
    nodeRole?: NullableStringFieldUpdateOperationsInput | string | null
    modelName?: NullableStringFieldUpdateOperationsInput | string | null
    dimensionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    retentionExpiresAt?: NullableStringFieldUpdateOperationsInput | string | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CredentialInstanceCreateInput = {
    instanceId: string
    typeId: string
    displayName: string
    sourceKind: string
    publicConfigJson: string
    secretRefJson: string
    tagsJson: string
    setupStatus: string
    createdAt: string
    updatedAt: string
    materialSource?: string
    materialRef?: string
  }

  export type CredentialInstanceUncheckedCreateInput = {
    instanceId: string
    typeId: string
    displayName: string
    sourceKind: string
    publicConfigJson: string
    secretRefJson: string
    tagsJson: string
    setupStatus: string
    createdAt: string
    updatedAt: string
    materialSource?: string
    materialRef?: string
  }

  export type CredentialInstanceUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    typeId?: StringFieldUpdateOperationsInput | string
    displayName?: StringFieldUpdateOperationsInput | string
    sourceKind?: StringFieldUpdateOperationsInput | string
    publicConfigJson?: StringFieldUpdateOperationsInput | string
    secretRefJson?: StringFieldUpdateOperationsInput | string
    tagsJson?: StringFieldUpdateOperationsInput | string
    setupStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    materialSource?: StringFieldUpdateOperationsInput | string
    materialRef?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialInstanceUncheckedUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    typeId?: StringFieldUpdateOperationsInput | string
    displayName?: StringFieldUpdateOperationsInput | string
    sourceKind?: StringFieldUpdateOperationsInput | string
    publicConfigJson?: StringFieldUpdateOperationsInput | string
    secretRefJson?: StringFieldUpdateOperationsInput | string
    tagsJson?: StringFieldUpdateOperationsInput | string
    setupStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    materialSource?: StringFieldUpdateOperationsInput | string
    materialRef?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialInstanceCreateManyInput = {
    instanceId: string
    typeId: string
    displayName: string
    sourceKind: string
    publicConfigJson: string
    secretRefJson: string
    tagsJson: string
    setupStatus: string
    createdAt: string
    updatedAt: string
    materialSource?: string
    materialRef?: string
  }

  export type CredentialInstanceUpdateManyMutationInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    typeId?: StringFieldUpdateOperationsInput | string
    displayName?: StringFieldUpdateOperationsInput | string
    sourceKind?: StringFieldUpdateOperationsInput | string
    publicConfigJson?: StringFieldUpdateOperationsInput | string
    secretRefJson?: StringFieldUpdateOperationsInput | string
    tagsJson?: StringFieldUpdateOperationsInput | string
    setupStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    materialSource?: StringFieldUpdateOperationsInput | string
    materialRef?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialInstanceUncheckedUpdateManyInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    typeId?: StringFieldUpdateOperationsInput | string
    displayName?: StringFieldUpdateOperationsInput | string
    sourceKind?: StringFieldUpdateOperationsInput | string
    publicConfigJson?: StringFieldUpdateOperationsInput | string
    secretRefJson?: StringFieldUpdateOperationsInput | string
    tagsJson?: StringFieldUpdateOperationsInput | string
    setupStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    materialSource?: StringFieldUpdateOperationsInput | string
    materialRef?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialSecretMaterialCreateInput = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    updatedAt: string
  }

  export type CredentialSecretMaterialUncheckedCreateInput = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    updatedAt: string
  }

  export type CredentialSecretMaterialUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialSecretMaterialUncheckedUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialSecretMaterialCreateManyInput = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    updatedAt: string
  }

  export type CredentialSecretMaterialUpdateManyMutationInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialSecretMaterialUncheckedUpdateManyInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2MaterialCreateInput = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    providerId: string
    connectedEmail?: string | null
    connectedAt?: string | null
    scopesJson: string
    updatedAt: string
  }

  export type CredentialOAuth2MaterialUncheckedCreateInput = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    providerId: string
    connectedEmail?: string | null
    connectedAt?: string | null
    scopesJson: string
    updatedAt: string
  }

  export type CredentialOAuth2MaterialUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    providerId?: StringFieldUpdateOperationsInput | string
    connectedEmail?: NullableStringFieldUpdateOperationsInput | string | null
    connectedAt?: NullableStringFieldUpdateOperationsInput | string | null
    scopesJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2MaterialUncheckedUpdateInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    providerId?: StringFieldUpdateOperationsInput | string
    connectedEmail?: NullableStringFieldUpdateOperationsInput | string | null
    connectedAt?: NullableStringFieldUpdateOperationsInput | string | null
    scopesJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2MaterialCreateManyInput = {
    instanceId: string
    encryptedJson: string
    encryptionKeyId: string
    schemaVersion: number
    providerId: string
    connectedEmail?: string | null
    connectedAt?: string | null
    scopesJson: string
    updatedAt: string
  }

  export type CredentialOAuth2MaterialUpdateManyMutationInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    providerId?: StringFieldUpdateOperationsInput | string
    connectedEmail?: NullableStringFieldUpdateOperationsInput | string | null
    connectedAt?: NullableStringFieldUpdateOperationsInput | string | null
    scopesJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2MaterialUncheckedUpdateManyInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    encryptedJson?: StringFieldUpdateOperationsInput | string
    encryptionKeyId?: StringFieldUpdateOperationsInput | string
    schemaVersion?: IntFieldUpdateOperationsInput | number
    providerId?: StringFieldUpdateOperationsInput | string
    connectedEmail?: NullableStringFieldUpdateOperationsInput | string | null
    connectedAt?: NullableStringFieldUpdateOperationsInput | string | null
    scopesJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2StateCreateInput = {
    state: string
    instanceId: string
    codeVerifier?: string | null
    providerId?: string | null
    requestedScopesJson: string
    createdAt: string
    expiresAt: string
  }

  export type CredentialOAuth2StateUncheckedCreateInput = {
    state: string
    instanceId: string
    codeVerifier?: string | null
    providerId?: string | null
    requestedScopesJson: string
    createdAt: string
    expiresAt: string
  }

  export type CredentialOAuth2StateUpdateInput = {
    state?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    codeVerifier?: NullableStringFieldUpdateOperationsInput | string | null
    providerId?: NullableStringFieldUpdateOperationsInput | string | null
    requestedScopesJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2StateUncheckedUpdateInput = {
    state?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    codeVerifier?: NullableStringFieldUpdateOperationsInput | string | null
    providerId?: NullableStringFieldUpdateOperationsInput | string | null
    requestedScopesJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2StateCreateManyInput = {
    state: string
    instanceId: string
    codeVerifier?: string | null
    providerId?: string | null
    requestedScopesJson: string
    createdAt: string
    expiresAt: string
  }

  export type CredentialOAuth2StateUpdateManyMutationInput = {
    state?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    codeVerifier?: NullableStringFieldUpdateOperationsInput | string | null
    providerId?: NullableStringFieldUpdateOperationsInput | string | null
    requestedScopesJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialOAuth2StateUncheckedUpdateManyInput = {
    state?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    codeVerifier?: NullableStringFieldUpdateOperationsInput | string | null
    providerId?: NullableStringFieldUpdateOperationsInput | string | null
    requestedScopesJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialBindingCreateInput = {
    workflowId: string
    nodeId: string
    slotKey: string
    instanceId: string
    updatedAt: string
  }

  export type CredentialBindingUncheckedCreateInput = {
    workflowId: string
    nodeId: string
    slotKey: string
    instanceId: string
    updatedAt: string
  }

  export type CredentialBindingUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    slotKey?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialBindingUncheckedUpdateInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    slotKey?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialBindingCreateManyInput = {
    workflowId: string
    nodeId: string
    slotKey: string
    instanceId: string
    updatedAt: string
  }

  export type CredentialBindingUpdateManyMutationInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    slotKey?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialBindingUncheckedUpdateManyInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    slotKey?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
  }

  export type CredentialTestResultCreateInput = {
    testId: string
    instanceId: string
    status: string
    message?: string | null
    detailsJson: string
    testedAt: string
    expiresAt?: string | null
  }

  export type CredentialTestResultUncheckedCreateInput = {
    testId: string
    instanceId: string
    status: string
    message?: string | null
    detailsJson: string
    testedAt: string
    expiresAt?: string | null
  }

  export type CredentialTestResultUpdateInput = {
    testId?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: StringFieldUpdateOperationsInput | string
    testedAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CredentialTestResultUncheckedUpdateInput = {
    testId?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: StringFieldUpdateOperationsInput | string
    testedAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CredentialTestResultCreateManyInput = {
    testId: string
    instanceId: string
    status: string
    message?: string | null
    detailsJson: string
    testedAt: string
    expiresAt?: string | null
  }

  export type CredentialTestResultUpdateManyMutationInput = {
    testId?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: StringFieldUpdateOperationsInput | string
    testedAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CredentialTestResultUncheckedUpdateManyInput = {
    testId?: StringFieldUpdateOperationsInput | string
    instanceId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: StringFieldUpdateOperationsInput | string
    testedAt?: StringFieldUpdateOperationsInput | string
    expiresAt?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserCreateInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    invites?: UserInviteCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    invites?: UserInviteUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    invites?: UserInviteUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    invites?: UserInviteUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserInviteCreateInput = {
    id?: string
    tokenHash: string
    expiresAt: Date | string
    createdAt: Date | string
    revokedAt?: Date | string | null
    user: UserCreateNestedOneWithoutInvitesInput
  }

  export type UserInviteUncheckedCreateInput = {
    id?: string
    userId: string
    tokenHash: string
    expiresAt: Date | string
    createdAt: Date | string
    revokedAt?: Date | string | null
  }

  export type UserInviteUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutInvitesNestedInput
  }

  export type UserInviteUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UserInviteCreateManyInput = {
    id?: string
    userId: string
    tokenHash: string
    expiresAt: Date | string
    createdAt: Date | string
    revokedAt?: Date | string | null
  }

  export type UserInviteUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UserInviteUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AccountCreateInput = {
    id?: string
    type?: string
    provider: string
    providerAccountId: string
    password?: string | null
    refresh_token?: string | null
    access_token?: string | null
    expires_at?: number | null
    accessTokenExpiresAt?: Date | string | null
    refreshTokenExpiresAt?: Date | string | null
    token_type?: string | null
    scope?: string | null
    id_token?: string | null
    session_state?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAccountsInput
  }

  export type AccountUncheckedCreateInput = {
    id?: string
    userId: string
    type?: string
    provider: string
    providerAccountId: string
    password?: string | null
    refresh_token?: string | null
    access_token?: string | null
    expires_at?: number | null
    accessTokenExpiresAt?: Date | string | null
    refreshTokenExpiresAt?: Date | string | null
    token_type?: string | null
    scope?: string | null
    id_token?: string | null
    session_state?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountCreateManyInput = {
    id?: string
    userId: string
    type?: string
    provider: string
    providerAccountId: string
    password?: string | null
    refresh_token?: string | null
    access_token?: string | null
    expires_at?: number | null
    accessTokenExpiresAt?: Date | string | null
    refreshTokenExpiresAt?: Date | string | null
    token_type?: string | null
    scope?: string | null
    id_token?: string | null
    session_state?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    ipAddress?: string | null
    userAgent?: string | null
    user: UserCreateNestedOneWithoutSessionsInput
  }

  export type SessionUncheckedCreateInput = {
    id?: string
    sessionToken: string
    userId: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    ipAddress?: string | null
    userAgent?: string | null
  }

  export type SessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    user?: UserUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type SessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionCreateManyInput = {
    id?: string
    sessionToken: string
    userId: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    ipAddress?: string | null
    userAgent?: string | null
  }

  export type SessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type VerificationTokenCreateInput = {
    id?: string
    identifier: string
    token: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VerificationTokenUncheckedCreateInput = {
    id?: string
    identifier: string
    token: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VerificationTokenUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    identifier?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VerificationTokenUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    identifier?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VerificationTokenCreateManyInput = {
    id?: string
    identifier: string
    token: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type VerificationTokenUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    identifier?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VerificationTokenUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    identifier?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WorkflowAuditLogCreateInput = {
    id: string
    occurredAt: Date | string
    actorUserId?: string | null
    actorSessionId?: string | null
    action: string
    resourceType: string
    resourceId: string
    outcome: string
    errorCode?: string | null
    correlationId?: string | null
    workflowId: string
    runId?: string | null
    nodeId?: string | null
  }

  export type WorkflowAuditLogUncheckedCreateInput = {
    id: string
    occurredAt: Date | string
    actorUserId?: string | null
    actorSessionId?: string | null
    action: string
    resourceType: string
    resourceId: string
    outcome: string
    errorCode?: string | null
    correlationId?: string | null
    workflowId: string
    runId?: string | null
    nodeId?: string | null
  }

  export type WorkflowAuditLogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actorUserId?: NullableStringFieldUpdateOperationsInput | string | null
    actorSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resourceType?: StringFieldUpdateOperationsInput | string
    resourceId?: StringFieldUpdateOperationsInput | string
    outcome?: StringFieldUpdateOperationsInput | string
    errorCode?: NullableStringFieldUpdateOperationsInput | string | null
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WorkflowAuditLogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actorUserId?: NullableStringFieldUpdateOperationsInput | string | null
    actorSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resourceType?: StringFieldUpdateOperationsInput | string
    resourceId?: StringFieldUpdateOperationsInput | string
    outcome?: StringFieldUpdateOperationsInput | string
    errorCode?: NullableStringFieldUpdateOperationsInput | string | null
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WorkflowAuditLogCreateManyInput = {
    id: string
    occurredAt: Date | string
    actorUserId?: string | null
    actorSessionId?: string | null
    action: string
    resourceType: string
    resourceId: string
    outcome: string
    errorCode?: string | null
    correlationId?: string | null
    workflowId: string
    runId?: string | null
    nodeId?: string | null
  }

  export type WorkflowAuditLogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actorUserId?: NullableStringFieldUpdateOperationsInput | string | null
    actorSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resourceType?: StringFieldUpdateOperationsInput | string
    resourceId?: StringFieldUpdateOperationsInput | string
    outcome?: StringFieldUpdateOperationsInput | string
    errorCode?: NullableStringFieldUpdateOperationsInput | string | null
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WorkflowAuditLogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actorUserId?: NullableStringFieldUpdateOperationsInput | string | null
    actorSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    action?: StringFieldUpdateOperationsInput | string
    resourceType?: StringFieldUpdateOperationsInput | string
    resourceId?: StringFieldUpdateOperationsInput | string
    outcome?: StringFieldUpdateOperationsInput | string
    errorCode?: NullableStringFieldUpdateOperationsInput | string | null
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    workflowId?: StringFieldUpdateOperationsInput | string
    runId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type HmacNonceCreateInput = {
    nonce: string
    expiresAt: Date | string
  }

  export type HmacNonceUncheckedCreateInput = {
    nonce: string
    expiresAt: Date | string
  }

  export type HmacNonceUpdateInput = {
    nonce?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HmacNonceUncheckedUpdateInput = {
    nonce?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HmacNonceCreateManyInput = {
    nonce: string
    expiresAt: Date | string
  }

  export type HmacNonceUpdateManyMutationInput = {
    nonce?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HmacNonceUncheckedUpdateManyInput = {
    nonce?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HumanTaskCreateInput = {
    id: string
    runId: string
    workflowId: string
    workspaceId?: string | null
    nodeId: string
    activationId: string
    itemIndex: number
    status: string
    channel: string
    subjectJson: string
    metadataJson: string
    decisionSchemaJson: string
    decisionSchemaHash: string
    onTimeout: string
    deliveryRefJson?: string | null
    decisionJson?: string | null
    decidedAt?: Date | string | null
    decidedByJson?: string | null
    resumeTokenHash: string
    expiresAt: Date | string
    createdAt?: Date | string
  }

  export type HumanTaskUncheckedCreateInput = {
    id: string
    runId: string
    workflowId: string
    workspaceId?: string | null
    nodeId: string
    activationId: string
    itemIndex: number
    status: string
    channel: string
    subjectJson: string
    metadataJson: string
    decisionSchemaJson: string
    decisionSchemaHash: string
    onTimeout: string
    deliveryRefJson?: string | null
    decisionJson?: string | null
    decidedAt?: Date | string | null
    decidedByJson?: string | null
    resumeTokenHash: string
    expiresAt: Date | string
    createdAt?: Date | string
  }

  export type HumanTaskUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    workspaceId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: StringFieldUpdateOperationsInput | string
    activationId?: StringFieldUpdateOperationsInput | string
    itemIndex?: IntFieldUpdateOperationsInput | number
    status?: StringFieldUpdateOperationsInput | string
    channel?: StringFieldUpdateOperationsInput | string
    subjectJson?: StringFieldUpdateOperationsInput | string
    metadataJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaHash?: StringFieldUpdateOperationsInput | string
    onTimeout?: StringFieldUpdateOperationsInput | string
    deliveryRefJson?: NullableStringFieldUpdateOperationsInput | string | null
    decisionJson?: NullableStringFieldUpdateOperationsInput | string | null
    decidedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    decidedByJson?: NullableStringFieldUpdateOperationsInput | string | null
    resumeTokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HumanTaskUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    workspaceId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: StringFieldUpdateOperationsInput | string
    activationId?: StringFieldUpdateOperationsInput | string
    itemIndex?: IntFieldUpdateOperationsInput | number
    status?: StringFieldUpdateOperationsInput | string
    channel?: StringFieldUpdateOperationsInput | string
    subjectJson?: StringFieldUpdateOperationsInput | string
    metadataJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaHash?: StringFieldUpdateOperationsInput | string
    onTimeout?: StringFieldUpdateOperationsInput | string
    deliveryRefJson?: NullableStringFieldUpdateOperationsInput | string | null
    decisionJson?: NullableStringFieldUpdateOperationsInput | string | null
    decidedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    decidedByJson?: NullableStringFieldUpdateOperationsInput | string | null
    resumeTokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HumanTaskCreateManyInput = {
    id: string
    runId: string
    workflowId: string
    workspaceId?: string | null
    nodeId: string
    activationId: string
    itemIndex: number
    status: string
    channel: string
    subjectJson: string
    metadataJson: string
    decisionSchemaJson: string
    decisionSchemaHash: string
    onTimeout: string
    deliveryRefJson?: string | null
    decisionJson?: string | null
    decidedAt?: Date | string | null
    decidedByJson?: string | null
    resumeTokenHash: string
    expiresAt: Date | string
    createdAt?: Date | string
  }

  export type HumanTaskUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    workspaceId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: StringFieldUpdateOperationsInput | string
    activationId?: StringFieldUpdateOperationsInput | string
    itemIndex?: IntFieldUpdateOperationsInput | number
    status?: StringFieldUpdateOperationsInput | string
    channel?: StringFieldUpdateOperationsInput | string
    subjectJson?: StringFieldUpdateOperationsInput | string
    metadataJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaHash?: StringFieldUpdateOperationsInput | string
    onTimeout?: StringFieldUpdateOperationsInput | string
    deliveryRefJson?: NullableStringFieldUpdateOperationsInput | string | null
    decisionJson?: NullableStringFieldUpdateOperationsInput | string | null
    decidedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    decidedByJson?: NullableStringFieldUpdateOperationsInput | string | null
    resumeTokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HumanTaskUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    workspaceId?: NullableStringFieldUpdateOperationsInput | string | null
    nodeId?: StringFieldUpdateOperationsInput | string
    activationId?: StringFieldUpdateOperationsInput | string
    itemIndex?: IntFieldUpdateOperationsInput | number
    status?: StringFieldUpdateOperationsInput | string
    channel?: StringFieldUpdateOperationsInput | string
    subjectJson?: StringFieldUpdateOperationsInput | string
    metadataJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaJson?: StringFieldUpdateOperationsInput | string
    decisionSchemaHash?: StringFieldUpdateOperationsInput | string
    onTimeout?: StringFieldUpdateOperationsInput | string
    deliveryRefJson?: NullableStringFieldUpdateOperationsInput | string | null
    decisionJson?: NullableStringFieldUpdateOperationsInput | string | null
    decidedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    decidedByJson?: NullableStringFieldUpdateOperationsInput | string | null
    resumeTokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

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

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

  export type RunWorkItemListRelationFilter = {
    every?: RunWorkItemWhereInput
    some?: RunWorkItemWhereInput
    none?: RunWorkItemWhereInput
  }

  export type ExecutionInstanceListRelationFilter = {
    every?: ExecutionInstanceWhereInput
    some?: ExecutionInstanceWhereInput
    none?: ExecutionInstanceWhereInput
  }

  export type RunSlotProjectionNullableScalarRelationFilter = {
    is?: RunSlotProjectionWhereInput | null
    isNot?: RunSlotProjectionWhereInput | null
  }

  export type TestSuiteRunNullableScalarRelationFilter = {
    is?: TestSuiteRunWhereInput | null
    isNot?: TestSuiteRunWhereInput | null
  }

  export type TestAssertionListRelationFilter = {
    every?: TestAssertionWhereInput
    some?: TestAssertionWhereInput
    none?: TestAssertionWhereInput
  }

  export type WorkflowSnapshotNullableScalarRelationFilter = {
    is?: WorkflowSnapshotWhereInput | null
    isNot?: WorkflowSnapshotWhereInput | null
  }

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

  export type RunWorkItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ExecutionInstanceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TestAssertionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type RunCountOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    status?: SortOrder
    revision?: SortOrder
    parentJson?: SortOrder
    executionOptionsJson?: SortOrder
    controlJson?: SortOrder
    workflowSnapshotJson?: SortOrder
    workflowSnapshotId?: SortOrder
    policySnapshotJson?: SortOrder
    engineCountersJson?: SortOrder
    mutableStateJson?: SortOrder
    hitlStateJson?: SortOrder
    outputsByNodeJson?: SortOrder
    updatedAt?: SortOrder
    testSuiteRunId?: SortOrder
    testCaseIndex?: SortOrder
    testCaseLabel?: SortOrder
    testCaseStatus?: SortOrder
  }

  export type RunAvgOrderByAggregateInput = {
    revision?: SortOrder
    testCaseIndex?: SortOrder
  }

  export type RunMaxOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    status?: SortOrder
    revision?: SortOrder
    parentJson?: SortOrder
    executionOptionsJson?: SortOrder
    controlJson?: SortOrder
    workflowSnapshotJson?: SortOrder
    workflowSnapshotId?: SortOrder
    policySnapshotJson?: SortOrder
    engineCountersJson?: SortOrder
    mutableStateJson?: SortOrder
    hitlStateJson?: SortOrder
    outputsByNodeJson?: SortOrder
    updatedAt?: SortOrder
    testSuiteRunId?: SortOrder
    testCaseIndex?: SortOrder
    testCaseLabel?: SortOrder
    testCaseStatus?: SortOrder
  }

  export type RunMinOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    status?: SortOrder
    revision?: SortOrder
    parentJson?: SortOrder
    executionOptionsJson?: SortOrder
    controlJson?: SortOrder
    workflowSnapshotJson?: SortOrder
    workflowSnapshotId?: SortOrder
    policySnapshotJson?: SortOrder
    engineCountersJson?: SortOrder
    mutableStateJson?: SortOrder
    hitlStateJson?: SortOrder
    outputsByNodeJson?: SortOrder
    updatedAt?: SortOrder
    testSuiteRunId?: SortOrder
    testCaseIndex?: SortOrder
    testCaseLabel?: SortOrder
    testCaseStatus?: SortOrder
  }

  export type RunSumOrderByAggregateInput = {
    revision?: SortOrder
    testCaseIndex?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type RunScalarRelationFilter = {
    is?: RunWhereInput
    isNot?: RunWhereInput
  }

  export type RunWorkItemCountOrderByAggregateInput = {
    workItemId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    status?: SortOrder
    targetNodeId?: SortOrder
    batchId?: SortOrder
    queueName?: SortOrder
    claimToken?: SortOrder
    claimedBy?: SortOrder
    claimedAt?: SortOrder
    availableAt?: SortOrder
    enqueuedAt?: SortOrder
    completedAt?: SortOrder
    failedAt?: SortOrder
    sourceInstanceId?: SortOrder
    parentInstanceId?: SortOrder
    itemsIn?: SortOrder
    inputsByPortJson?: SortOrder
    errorJson?: SortOrder
  }

  export type RunWorkItemAvgOrderByAggregateInput = {
    itemsIn?: SortOrder
  }

  export type RunWorkItemMaxOrderByAggregateInput = {
    workItemId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    status?: SortOrder
    targetNodeId?: SortOrder
    batchId?: SortOrder
    queueName?: SortOrder
    claimToken?: SortOrder
    claimedBy?: SortOrder
    claimedAt?: SortOrder
    availableAt?: SortOrder
    enqueuedAt?: SortOrder
    completedAt?: SortOrder
    failedAt?: SortOrder
    sourceInstanceId?: SortOrder
    parentInstanceId?: SortOrder
    itemsIn?: SortOrder
    inputsByPortJson?: SortOrder
    errorJson?: SortOrder
  }

  export type RunWorkItemMinOrderByAggregateInput = {
    workItemId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    status?: SortOrder
    targetNodeId?: SortOrder
    batchId?: SortOrder
    queueName?: SortOrder
    claimToken?: SortOrder
    claimedBy?: SortOrder
    claimedAt?: SortOrder
    availableAt?: SortOrder
    enqueuedAt?: SortOrder
    completedAt?: SortOrder
    failedAt?: SortOrder
    sourceInstanceId?: SortOrder
    parentInstanceId?: SortOrder
    itemsIn?: SortOrder
    inputsByPortJson?: SortOrder
    errorJson?: SortOrder
  }

  export type RunWorkItemSumOrderByAggregateInput = {
    itemsIn?: SortOrder
  }

  export type BoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  export type ExecutionInstanceRunIdSlotNodeIdRunIndexCompoundUniqueInput = {
    runId: string
    slotNodeId: string
    runIndex: number
  }

  export type ExecutionInstanceCountOrderByAggregateInput = {
    instanceId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    slotNodeId?: SortOrder
    workflowNodeId?: SortOrder
    kind?: SortOrder
    connectionKind?: SortOrder
    activationId?: SortOrder
    batchId?: SortOrder
    runIndex?: SortOrder
    parentInstanceId?: SortOrder
    parentRunId?: SortOrder
    workerClaimToken?: SortOrder
    status?: SortOrder
    queuedAt?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    updatedAt?: SortOrder
    itemCount?: SortOrder
    inputJson?: SortOrder
    outputJson?: SortOrder
    errorJson?: SortOrder
    inputItemIndicesJson?: SortOrder
    outputItemCount?: SortOrder
    successfulItemCount?: SortOrder
    failedItemCount?: SortOrder
    inputStorageKind?: SortOrder
    outputStorageKind?: SortOrder
    inputBytes?: SortOrder
    outputBytes?: SortOrder
    inputPreviewJson?: SortOrder
    outputPreviewJson?: SortOrder
    inputPayloadRef?: SortOrder
    outputPayloadRef?: SortOrder
    inputTruncated?: SortOrder
    outputTruncated?: SortOrder
    usedPinnedOutput?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
    childRunId?: SortOrder
  }

  export type ExecutionInstanceAvgOrderByAggregateInput = {
    runIndex?: SortOrder
    itemCount?: SortOrder
    outputItemCount?: SortOrder
    successfulItemCount?: SortOrder
    failedItemCount?: SortOrder
    inputBytes?: SortOrder
    outputBytes?: SortOrder
    itemIndex?: SortOrder
  }

  export type ExecutionInstanceMaxOrderByAggregateInput = {
    instanceId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    slotNodeId?: SortOrder
    workflowNodeId?: SortOrder
    kind?: SortOrder
    connectionKind?: SortOrder
    activationId?: SortOrder
    batchId?: SortOrder
    runIndex?: SortOrder
    parentInstanceId?: SortOrder
    parentRunId?: SortOrder
    workerClaimToken?: SortOrder
    status?: SortOrder
    queuedAt?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    updatedAt?: SortOrder
    itemCount?: SortOrder
    inputJson?: SortOrder
    outputJson?: SortOrder
    errorJson?: SortOrder
    inputItemIndicesJson?: SortOrder
    outputItemCount?: SortOrder
    successfulItemCount?: SortOrder
    failedItemCount?: SortOrder
    inputStorageKind?: SortOrder
    outputStorageKind?: SortOrder
    inputBytes?: SortOrder
    outputBytes?: SortOrder
    inputPreviewJson?: SortOrder
    outputPreviewJson?: SortOrder
    inputPayloadRef?: SortOrder
    outputPayloadRef?: SortOrder
    inputTruncated?: SortOrder
    outputTruncated?: SortOrder
    usedPinnedOutput?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
    childRunId?: SortOrder
  }

  export type ExecutionInstanceMinOrderByAggregateInput = {
    instanceId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    slotNodeId?: SortOrder
    workflowNodeId?: SortOrder
    kind?: SortOrder
    connectionKind?: SortOrder
    activationId?: SortOrder
    batchId?: SortOrder
    runIndex?: SortOrder
    parentInstanceId?: SortOrder
    parentRunId?: SortOrder
    workerClaimToken?: SortOrder
    status?: SortOrder
    queuedAt?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    updatedAt?: SortOrder
    itemCount?: SortOrder
    inputJson?: SortOrder
    outputJson?: SortOrder
    errorJson?: SortOrder
    inputItemIndicesJson?: SortOrder
    outputItemCount?: SortOrder
    successfulItemCount?: SortOrder
    failedItemCount?: SortOrder
    inputStorageKind?: SortOrder
    outputStorageKind?: SortOrder
    inputBytes?: SortOrder
    outputBytes?: SortOrder
    inputPreviewJson?: SortOrder
    outputPreviewJson?: SortOrder
    inputPayloadRef?: SortOrder
    outputPayloadRef?: SortOrder
    inputTruncated?: SortOrder
    outputTruncated?: SortOrder
    usedPinnedOutput?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
    childRunId?: SortOrder
  }

  export type ExecutionInstanceSumOrderByAggregateInput = {
    runIndex?: SortOrder
    itemCount?: SortOrder
    outputItemCount?: SortOrder
    successfulItemCount?: SortOrder
    failedItemCount?: SortOrder
    inputBytes?: SortOrder
    outputBytes?: SortOrder
    itemIndex?: 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 RunSlotProjectionCountOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    revision?: SortOrder
    updatedAt?: SortOrder
    slotStatesJson?: SortOrder
  }

  export type RunSlotProjectionAvgOrderByAggregateInput = {
    revision?: SortOrder
  }

  export type RunSlotProjectionMaxOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    revision?: SortOrder
    updatedAt?: SortOrder
    slotStatesJson?: SortOrder
  }

  export type RunSlotProjectionMinOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    revision?: SortOrder
    updatedAt?: SortOrder
    slotStatesJson?: SortOrder
  }

  export type RunSlotProjectionSumOrderByAggregateInput = {
    revision?: SortOrder
  }

  export type RunListRelationFilter = {
    every?: RunWhereInput
    some?: RunWhereInput
    none?: RunWhereInput
  }

  export type RunOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TestSuiteRunCountOrderByAggregateInput = {
    id?: SortOrder
    workflowId?: SortOrder
    triggerNodeId?: SortOrder
    triggerNodeName?: SortOrder
    status?: SortOrder
    concurrency?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
    nodeCoverageJson?: SortOrder
    errorMessage?: SortOrder
    updatedAt?: SortOrder
  }

  export type TestSuiteRunAvgOrderByAggregateInput = {
    concurrency?: SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
  }

  export type TestSuiteRunMaxOrderByAggregateInput = {
    id?: SortOrder
    workflowId?: SortOrder
    triggerNodeId?: SortOrder
    triggerNodeName?: SortOrder
    status?: SortOrder
    concurrency?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
    nodeCoverageJson?: SortOrder
    errorMessage?: SortOrder
    updatedAt?: SortOrder
  }

  export type TestSuiteRunMinOrderByAggregateInput = {
    id?: SortOrder
    workflowId?: SortOrder
    triggerNodeId?: SortOrder
    triggerNodeName?: SortOrder
    status?: SortOrder
    concurrency?: SortOrder
    startedAt?: SortOrder
    finishedAt?: SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
    nodeCoverageJson?: SortOrder
    errorMessage?: SortOrder
    updatedAt?: SortOrder
  }

  export type TestSuiteRunSumOrderByAggregateInput = {
    concurrency?: SortOrder
    totalCases?: SortOrder
    passedCases?: SortOrder
    failedCases?: SortOrder
  }

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

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

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type TestSuiteRunScalarRelationFilter = {
    is?: TestSuiteRunWhereInput
    isNot?: TestSuiteRunWhereInput
  }

  export type TestAssertionCountOrderByAggregateInput = {
    id?: SortOrder
    runId?: SortOrder
    testSuiteRunId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    name?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrder
    errored?: SortOrder
    expectedJson?: SortOrder
    actualJson?: SortOrder
    message?: SortOrder
    detailsJson?: SortOrder
    createdAt?: SortOrder
  }

  export type TestAssertionAvgOrderByAggregateInput = {
    itemIndex?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrder
  }

  export type TestAssertionMaxOrderByAggregateInput = {
    id?: SortOrder
    runId?: SortOrder
    testSuiteRunId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    name?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrder
    errored?: SortOrder
    expectedJson?: SortOrder
    actualJson?: SortOrder
    message?: SortOrder
    detailsJson?: SortOrder
    createdAt?: SortOrder
  }

  export type TestAssertionMinOrderByAggregateInput = {
    id?: SortOrder
    runId?: SortOrder
    testSuiteRunId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    name?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrder
    errored?: SortOrder
    expectedJson?: SortOrder
    actualJson?: SortOrder
    message?: SortOrder
    detailsJson?: SortOrder
    createdAt?: SortOrder
  }

  export type TestAssertionSumOrderByAggregateInput = {
    itemIndex?: SortOrder
    score?: SortOrder
    passThreshold?: SortOrder
  }

  export type FloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type WorkflowDebuggerOverlayCountOrderByAggregateInput = {
    workflowId?: SortOrder
    updatedAt?: SortOrder
    copiedFromRunId?: SortOrder
    stateJson?: SortOrder
  }

  export type WorkflowDebuggerOverlayMaxOrderByAggregateInput = {
    workflowId?: SortOrder
    updatedAt?: SortOrder
    copiedFromRunId?: SortOrder
    stateJson?: SortOrder
  }

  export type WorkflowDebuggerOverlayMinOrderByAggregateInput = {
    workflowId?: SortOrder
    updatedAt?: SortOrder
    copiedFromRunId?: SortOrder
    stateJson?: SortOrder
  }

  export type WorkflowActivationCountOrderByAggregateInput = {
    workflowId?: SortOrder
    isActive?: SortOrder
    updatedAt?: SortOrder
  }

  export type WorkflowActivationMaxOrderByAggregateInput = {
    workflowId?: SortOrder
    isActive?: SortOrder
    updatedAt?: SortOrder
  }

  export type WorkflowActivationMinOrderByAggregateInput = {
    workflowId?: SortOrder
    isActive?: SortOrder
    updatedAt?: SortOrder
  }

  export type TriggerSetupStateWorkflowIdNodeIdCompoundUniqueInput = {
    workflowId: string
    nodeId: string
  }

  export type TriggerSetupStateCountOrderByAggregateInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    updatedAt?: SortOrder
    stateJson?: SortOrder
  }

  export type TriggerSetupStateMaxOrderByAggregateInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    updatedAt?: SortOrder
    stateJson?: SortOrder
  }

  export type TriggerSetupStateMinOrderByAggregateInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    updatedAt?: SortOrder
    stateJson?: SortOrder
  }

  export type RunTraceContextCountOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    traceId?: SortOrder
    rootSpanId?: SortOrder
    serviceName?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type RunTraceContextMaxOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    traceId?: SortOrder
    rootSpanId?: SortOrder
    serviceName?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type RunTraceContextMinOrderByAggregateInput = {
    runId?: SortOrder
    workflowId?: SortOrder
    traceId?: SortOrder
    rootSpanId?: SortOrder
    serviceName?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type TelemetrySpanTraceIdSpanIdCompoundUniqueInput = {
    traceId: string
    spanId: string
  }

  export type TelemetrySpanCountOrderByAggregateInput = {
    telemetrySpanId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    parentSpanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    connectionInvocationId?: SortOrder
    name?: SortOrder
    kind?: SortOrder
    status?: SortOrder
    statusMessage?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    workflowFolder?: SortOrder
    nodeType?: SortOrder
    nodeRole?: SortOrder
    modelName?: SortOrder
    attributesJson?: SortOrder
    eventsJson?: SortOrder
    retentionExpiresAt?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
    updatedAt?: SortOrder
  }

  export type TelemetrySpanAvgOrderByAggregateInput = {
    itemIndex?: SortOrder
  }

  export type TelemetrySpanMaxOrderByAggregateInput = {
    telemetrySpanId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    parentSpanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    connectionInvocationId?: SortOrder
    name?: SortOrder
    kind?: SortOrder
    status?: SortOrder
    statusMessage?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    workflowFolder?: SortOrder
    nodeType?: SortOrder
    nodeRole?: SortOrder
    modelName?: SortOrder
    attributesJson?: SortOrder
    eventsJson?: SortOrder
    retentionExpiresAt?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
    updatedAt?: SortOrder
  }

  export type TelemetrySpanMinOrderByAggregateInput = {
    telemetrySpanId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    parentSpanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    connectionInvocationId?: SortOrder
    name?: SortOrder
    kind?: SortOrder
    status?: SortOrder
    statusMessage?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    workflowFolder?: SortOrder
    nodeType?: SortOrder
    nodeRole?: SortOrder
    modelName?: SortOrder
    attributesJson?: SortOrder
    eventsJson?: SortOrder
    retentionExpiresAt?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
    updatedAt?: SortOrder
  }

  export type TelemetrySpanSumOrderByAggregateInput = {
    itemIndex?: SortOrder
  }

  export type WorkflowSnapshotWorkflowIdSnapshotHashCompoundUniqueInput = {
    workflowId: string
    snapshotHash: string
  }

  export type WorkflowSnapshotCountOrderByAggregateInput = {
    id?: SortOrder
    workflowId?: SortOrder
    snapshotHash?: SortOrder
    snapshotJson?: SortOrder
    createdAt?: SortOrder
  }

  export type WorkflowSnapshotMaxOrderByAggregateInput = {
    id?: SortOrder
    workflowId?: SortOrder
    snapshotHash?: SortOrder
    snapshotJson?: SortOrder
    createdAt?: SortOrder
  }

  export type WorkflowSnapshotMinOrderByAggregateInput = {
    id?: SortOrder
    workflowId?: SortOrder
    snapshotHash?: SortOrder
    snapshotJson?: SortOrder
    createdAt?: SortOrder
  }

  export type TelemetryArtifactCountOrderByAggregateInput = {
    artifactId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    kind?: SortOrder
    contentType?: SortOrder
    previewText?: SortOrder
    previewJson?: SortOrder
    payloadText?: SortOrder
    payloadJson?: SortOrder
    payloadStorageKey?: SortOrder
    bytes?: SortOrder
    truncated?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    retentionExpiresAt?: SortOrder
  }

  export type TelemetryArtifactAvgOrderByAggregateInput = {
    bytes?: SortOrder
  }

  export type TelemetryArtifactMaxOrderByAggregateInput = {
    artifactId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    kind?: SortOrder
    contentType?: SortOrder
    previewText?: SortOrder
    previewJson?: SortOrder
    payloadText?: SortOrder
    payloadJson?: SortOrder
    payloadStorageKey?: SortOrder
    bytes?: SortOrder
    truncated?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    retentionExpiresAt?: SortOrder
  }

  export type TelemetryArtifactMinOrderByAggregateInput = {
    artifactId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    kind?: SortOrder
    contentType?: SortOrder
    previewText?: SortOrder
    previewJson?: SortOrder
    payloadText?: SortOrder
    payloadJson?: SortOrder
    payloadStorageKey?: SortOrder
    bytes?: SortOrder
    truncated?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    retentionExpiresAt?: SortOrder
  }

  export type TelemetryArtifactSumOrderByAggregateInput = {
    bytes?: SortOrder
  }

  export type TelemetryMetricPointCountOrderByAggregateInput = {
    metricPointId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    metricName?: SortOrder
    value?: SortOrder
    unit?: SortOrder
    observedAt?: SortOrder
    workflowFolder?: SortOrder
    nodeType?: SortOrder
    nodeRole?: SortOrder
    modelName?: SortOrder
    dimensionsJson?: SortOrder
    retentionExpiresAt?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
  }

  export type TelemetryMetricPointAvgOrderByAggregateInput = {
    value?: SortOrder
    itemIndex?: SortOrder
  }

  export type TelemetryMetricPointMaxOrderByAggregateInput = {
    metricPointId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    metricName?: SortOrder
    value?: SortOrder
    unit?: SortOrder
    observedAt?: SortOrder
    workflowFolder?: SortOrder
    nodeType?: SortOrder
    nodeRole?: SortOrder
    modelName?: SortOrder
    dimensionsJson?: SortOrder
    retentionExpiresAt?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
  }

  export type TelemetryMetricPointMinOrderByAggregateInput = {
    metricPointId?: SortOrder
    traceId?: SortOrder
    spanId?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    metricName?: SortOrder
    value?: SortOrder
    unit?: SortOrder
    observedAt?: SortOrder
    workflowFolder?: SortOrder
    nodeType?: SortOrder
    nodeRole?: SortOrder
    modelName?: SortOrder
    dimensionsJson?: SortOrder
    retentionExpiresAt?: SortOrder
    iterationId?: SortOrder
    itemIndex?: SortOrder
    parentInvocationId?: SortOrder
  }

  export type TelemetryMetricPointSumOrderByAggregateInput = {
    value?: SortOrder
    itemIndex?: SortOrder
  }

  export type CredentialInstanceCountOrderByAggregateInput = {
    instanceId?: SortOrder
    typeId?: SortOrder
    displayName?: SortOrder
    sourceKind?: SortOrder
    publicConfigJson?: SortOrder
    secretRefJson?: SortOrder
    tagsJson?: SortOrder
    setupStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    materialSource?: SortOrder
    materialRef?: SortOrder
  }

  export type CredentialInstanceMaxOrderByAggregateInput = {
    instanceId?: SortOrder
    typeId?: SortOrder
    displayName?: SortOrder
    sourceKind?: SortOrder
    publicConfigJson?: SortOrder
    secretRefJson?: SortOrder
    tagsJson?: SortOrder
    setupStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    materialSource?: SortOrder
    materialRef?: SortOrder
  }

  export type CredentialInstanceMinOrderByAggregateInput = {
    instanceId?: SortOrder
    typeId?: SortOrder
    displayName?: SortOrder
    sourceKind?: SortOrder
    publicConfigJson?: SortOrder
    secretRefJson?: SortOrder
    tagsJson?: SortOrder
    setupStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    materialSource?: SortOrder
    materialRef?: SortOrder
  }

  export type CredentialSecretMaterialCountOrderByAggregateInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialSecretMaterialAvgOrderByAggregateInput = {
    schemaVersion?: SortOrder
  }

  export type CredentialSecretMaterialMaxOrderByAggregateInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialSecretMaterialMinOrderByAggregateInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialSecretMaterialSumOrderByAggregateInput = {
    schemaVersion?: SortOrder
  }

  export type CredentialOAuth2MaterialCountOrderByAggregateInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    providerId?: SortOrder
    connectedEmail?: SortOrder
    connectedAt?: SortOrder
    scopesJson?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialOAuth2MaterialAvgOrderByAggregateInput = {
    schemaVersion?: SortOrder
  }

  export type CredentialOAuth2MaterialMaxOrderByAggregateInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    providerId?: SortOrder
    connectedEmail?: SortOrder
    connectedAt?: SortOrder
    scopesJson?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialOAuth2MaterialMinOrderByAggregateInput = {
    instanceId?: SortOrder
    encryptedJson?: SortOrder
    encryptionKeyId?: SortOrder
    schemaVersion?: SortOrder
    providerId?: SortOrder
    connectedEmail?: SortOrder
    connectedAt?: SortOrder
    scopesJson?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialOAuth2MaterialSumOrderByAggregateInput = {
    schemaVersion?: SortOrder
  }

  export type CredentialOAuth2StateCountOrderByAggregateInput = {
    state?: SortOrder
    instanceId?: SortOrder
    codeVerifier?: SortOrder
    providerId?: SortOrder
    requestedScopesJson?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type CredentialOAuth2StateMaxOrderByAggregateInput = {
    state?: SortOrder
    instanceId?: SortOrder
    codeVerifier?: SortOrder
    providerId?: SortOrder
    requestedScopesJson?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type CredentialOAuth2StateMinOrderByAggregateInput = {
    state?: SortOrder
    instanceId?: SortOrder
    codeVerifier?: SortOrder
    providerId?: SortOrder
    requestedScopesJson?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type CredentialBindingWorkflowIdNodeIdSlotKeyCompoundUniqueInput = {
    workflowId: string
    nodeId: string
    slotKey: string
  }

  export type CredentialBindingCountOrderByAggregateInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    slotKey?: SortOrder
    instanceId?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialBindingMaxOrderByAggregateInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    slotKey?: SortOrder
    instanceId?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialBindingMinOrderByAggregateInput = {
    workflowId?: SortOrder
    nodeId?: SortOrder
    slotKey?: SortOrder
    instanceId?: SortOrder
    updatedAt?: SortOrder
  }

  export type CredentialTestResultCountOrderByAggregateInput = {
    testId?: SortOrder
    instanceId?: SortOrder
    status?: SortOrder
    message?: SortOrder
    detailsJson?: SortOrder
    testedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type CredentialTestResultMaxOrderByAggregateInput = {
    testId?: SortOrder
    instanceId?: SortOrder
    status?: SortOrder
    message?: SortOrder
    detailsJson?: SortOrder
    testedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type CredentialTestResultMinOrderByAggregateInput = {
    testId?: SortOrder
    instanceId?: SortOrder
    status?: SortOrder
    message?: SortOrder
    detailsJson?: SortOrder
    testedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type AccountListRelationFilter = {
    every?: AccountWhereInput
    some?: AccountWhereInput
    none?: AccountWhereInput
  }

  export type SessionListRelationFilter = {
    every?: SessionWhereInput
    some?: SessionWhereInput
    none?: SessionWhereInput
  }

  export type UserInviteListRelationFilter = {
    every?: UserInviteWhereInput
    some?: UserInviteWhereInput
    none?: UserInviteWhereInput
  }

  export type AccountOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserInviteOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    image?: SortOrder
    passwordHash?: SortOrder
    accountStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    image?: SortOrder
    passwordHash?: SortOrder
    accountStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    image?: SortOrder
    passwordHash?: SortOrder
    accountStatus?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type UserScalarRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type UserInviteCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrder
  }

  export type UserInviteMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrder
  }

  export type UserInviteMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrder
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type AccountProviderProviderAccountIdCompoundUniqueInput = {
    provider: string
    providerAccountId: string
  }

  export type AccountCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    password?: SortOrder
    refresh_token?: SortOrder
    access_token?: SortOrder
    expires_at?: SortOrder
    accessTokenExpiresAt?: SortOrder
    refreshTokenExpiresAt?: SortOrder
    token_type?: SortOrder
    scope?: SortOrder
    id_token?: SortOrder
    session_state?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountAvgOrderByAggregateInput = {
    expires_at?: SortOrder
  }

  export type AccountMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    password?: SortOrder
    refresh_token?: SortOrder
    access_token?: SortOrder
    expires_at?: SortOrder
    accessTokenExpiresAt?: SortOrder
    refreshTokenExpiresAt?: SortOrder
    token_type?: SortOrder
    scope?: SortOrder
    id_token?: SortOrder
    session_state?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    type?: SortOrder
    provider?: SortOrder
    providerAccountId?: SortOrder
    password?: SortOrder
    refresh_token?: SortOrder
    access_token?: SortOrder
    expires_at?: SortOrder
    accessTokenExpiresAt?: SortOrder
    refreshTokenExpiresAt?: SortOrder
    token_type?: SortOrder
    scope?: SortOrder
    id_token?: SortOrder
    session_state?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountSumOrderByAggregateInput = {
    expires_at?: SortOrder
  }

  export type SessionCountOrderByAggregateInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
  }

  export type SessionMaxOrderByAggregateInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
  }

  export type SessionMinOrderByAggregateInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
  }

  export type VerificationTokenIdentifierTokenCompoundUniqueInput = {
    identifier: string
    token: string
  }

  export type VerificationTokenCountOrderByAggregateInput = {
    id?: SortOrder
    identifier?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type VerificationTokenMaxOrderByAggregateInput = {
    id?: SortOrder
    identifier?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type VerificationTokenMinOrderByAggregateInput = {
    id?: SortOrder
    identifier?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type WorkflowAuditLogCountOrderByAggregateInput = {
    id?: SortOrder
    occurredAt?: SortOrder
    actorUserId?: SortOrder
    actorSessionId?: SortOrder
    action?: SortOrder
    resourceType?: SortOrder
    resourceId?: SortOrder
    outcome?: SortOrder
    errorCode?: SortOrder
    correlationId?: SortOrder
    workflowId?: SortOrder
    runId?: SortOrder
    nodeId?: SortOrder
  }

  export type WorkflowAuditLogMaxOrderByAggregateInput = {
    id?: SortOrder
    occurredAt?: SortOrder
    actorUserId?: SortOrder
    actorSessionId?: SortOrder
    action?: SortOrder
    resourceType?: SortOrder
    resourceId?: SortOrder
    outcome?: SortOrder
    errorCode?: SortOrder
    correlationId?: SortOrder
    workflowId?: SortOrder
    runId?: SortOrder
    nodeId?: SortOrder
  }

  export type WorkflowAuditLogMinOrderByAggregateInput = {
    id?: SortOrder
    occurredAt?: SortOrder
    actorUserId?: SortOrder
    actorSessionId?: SortOrder
    action?: SortOrder
    resourceType?: SortOrder
    resourceId?: SortOrder
    outcome?: SortOrder
    errorCode?: SortOrder
    correlationId?: SortOrder
    workflowId?: SortOrder
    runId?: SortOrder
    nodeId?: SortOrder
  }

  export type HmacNonceCountOrderByAggregateInput = {
    nonce?: SortOrder
    expiresAt?: SortOrder
  }

  export type HmacNonceMaxOrderByAggregateInput = {
    nonce?: SortOrder
    expiresAt?: SortOrder
  }

  export type HmacNonceMinOrderByAggregateInput = {
    nonce?: SortOrder
    expiresAt?: SortOrder
  }

  export type HumanTaskCountOrderByAggregateInput = {
    id?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    workspaceId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    itemIndex?: SortOrder
    status?: SortOrder
    channel?: SortOrder
    subjectJson?: SortOrder
    metadataJson?: SortOrder
    decisionSchemaJson?: SortOrder
    decisionSchemaHash?: SortOrder
    onTimeout?: SortOrder
    deliveryRefJson?: SortOrder
    decisionJson?: SortOrder
    decidedAt?: SortOrder
    decidedByJson?: SortOrder
    resumeTokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
  }

  export type HumanTaskAvgOrderByAggregateInput = {
    itemIndex?: SortOrder
  }

  export type HumanTaskMaxOrderByAggregateInput = {
    id?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    workspaceId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    itemIndex?: SortOrder
    status?: SortOrder
    channel?: SortOrder
    subjectJson?: SortOrder
    metadataJson?: SortOrder
    decisionSchemaJson?: SortOrder
    decisionSchemaHash?: SortOrder
    onTimeout?: SortOrder
    deliveryRefJson?: SortOrder
    decisionJson?: SortOrder
    decidedAt?: SortOrder
    decidedByJson?: SortOrder
    resumeTokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
  }

  export type HumanTaskMinOrderByAggregateInput = {
    id?: SortOrder
    runId?: SortOrder
    workflowId?: SortOrder
    workspaceId?: SortOrder
    nodeId?: SortOrder
    activationId?: SortOrder
    itemIndex?: SortOrder
    status?: SortOrder
    channel?: SortOrder
    subjectJson?: SortOrder
    metadataJson?: SortOrder
    decisionSchemaJson?: SortOrder
    decisionSchemaHash?: SortOrder
    onTimeout?: SortOrder
    deliveryRefJson?: SortOrder
    decisionJson?: SortOrder
    decidedAt?: SortOrder
    decidedByJson?: SortOrder
    resumeTokenHash?: SortOrder
    expiresAt?: SortOrder
    createdAt?: SortOrder
  }

  export type HumanTaskSumOrderByAggregateInput = {
    itemIndex?: SortOrder
  }

  export type RunWorkItemCreateNestedManyWithoutRunInput = {
    create?: XOR<RunWorkItemCreateWithoutRunInput, RunWorkItemUncheckedCreateWithoutRunInput> | RunWorkItemCreateWithoutRunInput[] | RunWorkItemUncheckedCreateWithoutRunInput[]
    connectOrCreate?: RunWorkItemCreateOrConnectWithoutRunInput | RunWorkItemCreateOrConnectWithoutRunInput[]
    createMany?: RunWorkItemCreateManyRunInputEnvelope
    connect?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
  }

  export type ExecutionInstanceCreateNestedManyWithoutRunInput = {
    create?: XOR<ExecutionInstanceCreateWithoutRunInput, ExecutionInstanceUncheckedCreateWithoutRunInput> | ExecutionInstanceCreateWithoutRunInput[] | ExecutionInstanceUncheckedCreateWithoutRunInput[]
    connectOrCreate?: ExecutionInstanceCreateOrConnectWithoutRunInput | ExecutionInstanceCreateOrConnectWithoutRunInput[]
    createMany?: ExecutionInstanceCreateManyRunInputEnvelope
    connect?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
  }

  export type RunSlotProjectionCreateNestedOneWithoutRunInput = {
    create?: XOR<RunSlotProjectionCreateWithoutRunInput, RunSlotProjectionUncheckedCreateWithoutRunInput>
    connectOrCreate?: RunSlotProjectionCreateOrConnectWithoutRunInput
    connect?: RunSlotProjectionWhereUniqueInput
  }

  export type TestSuiteRunCreateNestedOneWithoutRunsInput = {
    create?: XOR<TestSuiteRunCreateWithoutRunsInput, TestSuiteRunUncheckedCreateWithoutRunsInput>
    connectOrCreate?: TestSuiteRunCreateOrConnectWithoutRunsInput
    connect?: TestSuiteRunWhereUniqueInput
  }

  export type TestAssertionCreateNestedManyWithoutRunInput = {
    create?: XOR<TestAssertionCreateWithoutRunInput, TestAssertionUncheckedCreateWithoutRunInput> | TestAssertionCreateWithoutRunInput[] | TestAssertionUncheckedCreateWithoutRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutRunInput | TestAssertionCreateOrConnectWithoutRunInput[]
    createMany?: TestAssertionCreateManyRunInputEnvelope
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
  }

  export type WorkflowSnapshotCreateNestedOneWithoutRunsInput = {
    create?: XOR<WorkflowSnapshotCreateWithoutRunsInput, WorkflowSnapshotUncheckedCreateWithoutRunsInput>
    connectOrCreate?: WorkflowSnapshotCreateOrConnectWithoutRunsInput
    connect?: WorkflowSnapshotWhereUniqueInput
  }

  export type RunWorkItemUncheckedCreateNestedManyWithoutRunInput = {
    create?: XOR<RunWorkItemCreateWithoutRunInput, RunWorkItemUncheckedCreateWithoutRunInput> | RunWorkItemCreateWithoutRunInput[] | RunWorkItemUncheckedCreateWithoutRunInput[]
    connectOrCreate?: RunWorkItemCreateOrConnectWithoutRunInput | RunWorkItemCreateOrConnectWithoutRunInput[]
    createMany?: RunWorkItemCreateManyRunInputEnvelope
    connect?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
  }

  export type ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput = {
    create?: XOR<ExecutionInstanceCreateWithoutRunInput, ExecutionInstanceUncheckedCreateWithoutRunInput> | ExecutionInstanceCreateWithoutRunInput[] | ExecutionInstanceUncheckedCreateWithoutRunInput[]
    connectOrCreate?: ExecutionInstanceCreateOrConnectWithoutRunInput | ExecutionInstanceCreateOrConnectWithoutRunInput[]
    createMany?: ExecutionInstanceCreateManyRunInputEnvelope
    connect?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
  }

  export type RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput = {
    create?: XOR<RunSlotProjectionCreateWithoutRunInput, RunSlotProjectionUncheckedCreateWithoutRunInput>
    connectOrCreate?: RunSlotProjectionCreateOrConnectWithoutRunInput
    connect?: RunSlotProjectionWhereUniqueInput
  }

  export type TestAssertionUncheckedCreateNestedManyWithoutRunInput = {
    create?: XOR<TestAssertionCreateWithoutRunInput, TestAssertionUncheckedCreateWithoutRunInput> | TestAssertionCreateWithoutRunInput[] | TestAssertionUncheckedCreateWithoutRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutRunInput | TestAssertionCreateOrConnectWithoutRunInput[]
    createMany?: TestAssertionCreateManyRunInputEnvelope
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

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

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

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

  export type RunWorkItemUpdateManyWithoutRunNestedInput = {
    create?: XOR<RunWorkItemCreateWithoutRunInput, RunWorkItemUncheckedCreateWithoutRunInput> | RunWorkItemCreateWithoutRunInput[] | RunWorkItemUncheckedCreateWithoutRunInput[]
    connectOrCreate?: RunWorkItemCreateOrConnectWithoutRunInput | RunWorkItemCreateOrConnectWithoutRunInput[]
    upsert?: RunWorkItemUpsertWithWhereUniqueWithoutRunInput | RunWorkItemUpsertWithWhereUniqueWithoutRunInput[]
    createMany?: RunWorkItemCreateManyRunInputEnvelope
    set?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    disconnect?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    delete?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    connect?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    update?: RunWorkItemUpdateWithWhereUniqueWithoutRunInput | RunWorkItemUpdateWithWhereUniqueWithoutRunInput[]
    updateMany?: RunWorkItemUpdateManyWithWhereWithoutRunInput | RunWorkItemUpdateManyWithWhereWithoutRunInput[]
    deleteMany?: RunWorkItemScalarWhereInput | RunWorkItemScalarWhereInput[]
  }

  export type ExecutionInstanceUpdateManyWithoutRunNestedInput = {
    create?: XOR<ExecutionInstanceCreateWithoutRunInput, ExecutionInstanceUncheckedCreateWithoutRunInput> | ExecutionInstanceCreateWithoutRunInput[] | ExecutionInstanceUncheckedCreateWithoutRunInput[]
    connectOrCreate?: ExecutionInstanceCreateOrConnectWithoutRunInput | ExecutionInstanceCreateOrConnectWithoutRunInput[]
    upsert?: ExecutionInstanceUpsertWithWhereUniqueWithoutRunInput | ExecutionInstanceUpsertWithWhereUniqueWithoutRunInput[]
    createMany?: ExecutionInstanceCreateManyRunInputEnvelope
    set?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    disconnect?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    delete?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    connect?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    update?: ExecutionInstanceUpdateWithWhereUniqueWithoutRunInput | ExecutionInstanceUpdateWithWhereUniqueWithoutRunInput[]
    updateMany?: ExecutionInstanceUpdateManyWithWhereWithoutRunInput | ExecutionInstanceUpdateManyWithWhereWithoutRunInput[]
    deleteMany?: ExecutionInstanceScalarWhereInput | ExecutionInstanceScalarWhereInput[]
  }

  export type RunSlotProjectionUpdateOneWithoutRunNestedInput = {
    create?: XOR<RunSlotProjectionCreateWithoutRunInput, RunSlotProjectionUncheckedCreateWithoutRunInput>
    connectOrCreate?: RunSlotProjectionCreateOrConnectWithoutRunInput
    upsert?: RunSlotProjectionUpsertWithoutRunInput
    disconnect?: RunSlotProjectionWhereInput | boolean
    delete?: RunSlotProjectionWhereInput | boolean
    connect?: RunSlotProjectionWhereUniqueInput
    update?: XOR<XOR<RunSlotProjectionUpdateToOneWithWhereWithoutRunInput, RunSlotProjectionUpdateWithoutRunInput>, RunSlotProjectionUncheckedUpdateWithoutRunInput>
  }

  export type TestSuiteRunUpdateOneWithoutRunsNestedInput = {
    create?: XOR<TestSuiteRunCreateWithoutRunsInput, TestSuiteRunUncheckedCreateWithoutRunsInput>
    connectOrCreate?: TestSuiteRunCreateOrConnectWithoutRunsInput
    upsert?: TestSuiteRunUpsertWithoutRunsInput
    disconnect?: TestSuiteRunWhereInput | boolean
    delete?: TestSuiteRunWhereInput | boolean
    connect?: TestSuiteRunWhereUniqueInput
    update?: XOR<XOR<TestSuiteRunUpdateToOneWithWhereWithoutRunsInput, TestSuiteRunUpdateWithoutRunsInput>, TestSuiteRunUncheckedUpdateWithoutRunsInput>
  }

  export type TestAssertionUpdateManyWithoutRunNestedInput = {
    create?: XOR<TestAssertionCreateWithoutRunInput, TestAssertionUncheckedCreateWithoutRunInput> | TestAssertionCreateWithoutRunInput[] | TestAssertionUncheckedCreateWithoutRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutRunInput | TestAssertionCreateOrConnectWithoutRunInput[]
    upsert?: TestAssertionUpsertWithWhereUniqueWithoutRunInput | TestAssertionUpsertWithWhereUniqueWithoutRunInput[]
    createMany?: TestAssertionCreateManyRunInputEnvelope
    set?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    disconnect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    delete?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    update?: TestAssertionUpdateWithWhereUniqueWithoutRunInput | TestAssertionUpdateWithWhereUniqueWithoutRunInput[]
    updateMany?: TestAssertionUpdateManyWithWhereWithoutRunInput | TestAssertionUpdateManyWithWhereWithoutRunInput[]
    deleteMany?: TestAssertionScalarWhereInput | TestAssertionScalarWhereInput[]
  }

  export type WorkflowSnapshotUpdateOneWithoutRunsNestedInput = {
    create?: XOR<WorkflowSnapshotCreateWithoutRunsInput, WorkflowSnapshotUncheckedCreateWithoutRunsInput>
    connectOrCreate?: WorkflowSnapshotCreateOrConnectWithoutRunsInput
    upsert?: WorkflowSnapshotUpsertWithoutRunsInput
    disconnect?: WorkflowSnapshotWhereInput | boolean
    delete?: WorkflowSnapshotWhereInput | boolean
    connect?: WorkflowSnapshotWhereUniqueInput
    update?: XOR<XOR<WorkflowSnapshotUpdateToOneWithWhereWithoutRunsInput, WorkflowSnapshotUpdateWithoutRunsInput>, WorkflowSnapshotUncheckedUpdateWithoutRunsInput>
  }

  export type RunWorkItemUncheckedUpdateManyWithoutRunNestedInput = {
    create?: XOR<RunWorkItemCreateWithoutRunInput, RunWorkItemUncheckedCreateWithoutRunInput> | RunWorkItemCreateWithoutRunInput[] | RunWorkItemUncheckedCreateWithoutRunInput[]
    connectOrCreate?: RunWorkItemCreateOrConnectWithoutRunInput | RunWorkItemCreateOrConnectWithoutRunInput[]
    upsert?: RunWorkItemUpsertWithWhereUniqueWithoutRunInput | RunWorkItemUpsertWithWhereUniqueWithoutRunInput[]
    createMany?: RunWorkItemCreateManyRunInputEnvelope
    set?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    disconnect?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    delete?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    connect?: RunWorkItemWhereUniqueInput | RunWorkItemWhereUniqueInput[]
    update?: RunWorkItemUpdateWithWhereUniqueWithoutRunInput | RunWorkItemUpdateWithWhereUniqueWithoutRunInput[]
    updateMany?: RunWorkItemUpdateManyWithWhereWithoutRunInput | RunWorkItemUpdateManyWithWhereWithoutRunInput[]
    deleteMany?: RunWorkItemScalarWhereInput | RunWorkItemScalarWhereInput[]
  }

  export type ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput = {
    create?: XOR<ExecutionInstanceCreateWithoutRunInput, ExecutionInstanceUncheckedCreateWithoutRunInput> | ExecutionInstanceCreateWithoutRunInput[] | ExecutionInstanceUncheckedCreateWithoutRunInput[]
    connectOrCreate?: ExecutionInstanceCreateOrConnectWithoutRunInput | ExecutionInstanceCreateOrConnectWithoutRunInput[]
    upsert?: ExecutionInstanceUpsertWithWhereUniqueWithoutRunInput | ExecutionInstanceUpsertWithWhereUniqueWithoutRunInput[]
    createMany?: ExecutionInstanceCreateManyRunInputEnvelope
    set?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    disconnect?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    delete?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    connect?: ExecutionInstanceWhereUniqueInput | ExecutionInstanceWhereUniqueInput[]
    update?: ExecutionInstanceUpdateWithWhereUniqueWithoutRunInput | ExecutionInstanceUpdateWithWhereUniqueWithoutRunInput[]
    updateMany?: ExecutionInstanceUpdateManyWithWhereWithoutRunInput | ExecutionInstanceUpdateManyWithWhereWithoutRunInput[]
    deleteMany?: ExecutionInstanceScalarWhereInput | ExecutionInstanceScalarWhereInput[]
  }

  export type RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput = {
    create?: XOR<RunSlotProjectionCreateWithoutRunInput, RunSlotProjectionUncheckedCreateWithoutRunInput>
    connectOrCreate?: RunSlotProjectionCreateOrConnectWithoutRunInput
    upsert?: RunSlotProjectionUpsertWithoutRunInput
    disconnect?: RunSlotProjectionWhereInput | boolean
    delete?: RunSlotProjectionWhereInput | boolean
    connect?: RunSlotProjectionWhereUniqueInput
    update?: XOR<XOR<RunSlotProjectionUpdateToOneWithWhereWithoutRunInput, RunSlotProjectionUpdateWithoutRunInput>, RunSlotProjectionUncheckedUpdateWithoutRunInput>
  }

  export type TestAssertionUncheckedUpdateManyWithoutRunNestedInput = {
    create?: XOR<TestAssertionCreateWithoutRunInput, TestAssertionUncheckedCreateWithoutRunInput> | TestAssertionCreateWithoutRunInput[] | TestAssertionUncheckedCreateWithoutRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutRunInput | TestAssertionCreateOrConnectWithoutRunInput[]
    upsert?: TestAssertionUpsertWithWhereUniqueWithoutRunInput | TestAssertionUpsertWithWhereUniqueWithoutRunInput[]
    createMany?: TestAssertionCreateManyRunInputEnvelope
    set?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    disconnect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    delete?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    update?: TestAssertionUpdateWithWhereUniqueWithoutRunInput | TestAssertionUpdateWithWhereUniqueWithoutRunInput[]
    updateMany?: TestAssertionUpdateManyWithWhereWithoutRunInput | TestAssertionUpdateManyWithWhereWithoutRunInput[]
    deleteMany?: TestAssertionScalarWhereInput | TestAssertionScalarWhereInput[]
  }

  export type RunCreateNestedOneWithoutWorkItemsInput = {
    create?: XOR<RunCreateWithoutWorkItemsInput, RunUncheckedCreateWithoutWorkItemsInput>
    connectOrCreate?: RunCreateOrConnectWithoutWorkItemsInput
    connect?: RunWhereUniqueInput
  }

  export type RunUpdateOneRequiredWithoutWorkItemsNestedInput = {
    create?: XOR<RunCreateWithoutWorkItemsInput, RunUncheckedCreateWithoutWorkItemsInput>
    connectOrCreate?: RunCreateOrConnectWithoutWorkItemsInput
    upsert?: RunUpsertWithoutWorkItemsInput
    connect?: RunWhereUniqueInput
    update?: XOR<XOR<RunUpdateToOneWithWhereWithoutWorkItemsInput, RunUpdateWithoutWorkItemsInput>, RunUncheckedUpdateWithoutWorkItemsInput>
  }

  export type RunCreateNestedOneWithoutExecutionInstancesInput = {
    create?: XOR<RunCreateWithoutExecutionInstancesInput, RunUncheckedCreateWithoutExecutionInstancesInput>
    connectOrCreate?: RunCreateOrConnectWithoutExecutionInstancesInput
    connect?: RunWhereUniqueInput
  }

  export type NullableBoolFieldUpdateOperationsInput = {
    set?: boolean | null
  }

  export type RunUpdateOneRequiredWithoutExecutionInstancesNestedInput = {
    create?: XOR<RunCreateWithoutExecutionInstancesInput, RunUncheckedCreateWithoutExecutionInstancesInput>
    connectOrCreate?: RunCreateOrConnectWithoutExecutionInstancesInput
    upsert?: RunUpsertWithoutExecutionInstancesInput
    connect?: RunWhereUniqueInput
    update?: XOR<XOR<RunUpdateToOneWithWhereWithoutExecutionInstancesInput, RunUpdateWithoutExecutionInstancesInput>, RunUncheckedUpdateWithoutExecutionInstancesInput>
  }

  export type RunCreateNestedOneWithoutSlotProjectionInput = {
    create?: XOR<RunCreateWithoutSlotProjectionInput, RunUncheckedCreateWithoutSlotProjectionInput>
    connectOrCreate?: RunCreateOrConnectWithoutSlotProjectionInput
    connect?: RunWhereUniqueInput
  }

  export type RunUpdateOneRequiredWithoutSlotProjectionNestedInput = {
    create?: XOR<RunCreateWithoutSlotProjectionInput, RunUncheckedCreateWithoutSlotProjectionInput>
    connectOrCreate?: RunCreateOrConnectWithoutSlotProjectionInput
    upsert?: RunUpsertWithoutSlotProjectionInput
    connect?: RunWhereUniqueInput
    update?: XOR<XOR<RunUpdateToOneWithWhereWithoutSlotProjectionInput, RunUpdateWithoutSlotProjectionInput>, RunUncheckedUpdateWithoutSlotProjectionInput>
  }

  export type RunCreateNestedManyWithoutTestSuiteRunInput = {
    create?: XOR<RunCreateWithoutTestSuiteRunInput, RunUncheckedCreateWithoutTestSuiteRunInput> | RunCreateWithoutTestSuiteRunInput[] | RunUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: RunCreateOrConnectWithoutTestSuiteRunInput | RunCreateOrConnectWithoutTestSuiteRunInput[]
    createMany?: RunCreateManyTestSuiteRunInputEnvelope
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
  }

  export type TestAssertionCreateNestedManyWithoutTestSuiteRunInput = {
    create?: XOR<TestAssertionCreateWithoutTestSuiteRunInput, TestAssertionUncheckedCreateWithoutTestSuiteRunInput> | TestAssertionCreateWithoutTestSuiteRunInput[] | TestAssertionUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutTestSuiteRunInput | TestAssertionCreateOrConnectWithoutTestSuiteRunInput[]
    createMany?: TestAssertionCreateManyTestSuiteRunInputEnvelope
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
  }

  export type RunUncheckedCreateNestedManyWithoutTestSuiteRunInput = {
    create?: XOR<RunCreateWithoutTestSuiteRunInput, RunUncheckedCreateWithoutTestSuiteRunInput> | RunCreateWithoutTestSuiteRunInput[] | RunUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: RunCreateOrConnectWithoutTestSuiteRunInput | RunCreateOrConnectWithoutTestSuiteRunInput[]
    createMany?: RunCreateManyTestSuiteRunInputEnvelope
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
  }

  export type TestAssertionUncheckedCreateNestedManyWithoutTestSuiteRunInput = {
    create?: XOR<TestAssertionCreateWithoutTestSuiteRunInput, TestAssertionUncheckedCreateWithoutTestSuiteRunInput> | TestAssertionCreateWithoutTestSuiteRunInput[] | TestAssertionUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutTestSuiteRunInput | TestAssertionCreateOrConnectWithoutTestSuiteRunInput[]
    createMany?: TestAssertionCreateManyTestSuiteRunInputEnvelope
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
  }

  export type RunUpdateManyWithoutTestSuiteRunNestedInput = {
    create?: XOR<RunCreateWithoutTestSuiteRunInput, RunUncheckedCreateWithoutTestSuiteRunInput> | RunCreateWithoutTestSuiteRunInput[] | RunUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: RunCreateOrConnectWithoutTestSuiteRunInput | RunCreateOrConnectWithoutTestSuiteRunInput[]
    upsert?: RunUpsertWithWhereUniqueWithoutTestSuiteRunInput | RunUpsertWithWhereUniqueWithoutTestSuiteRunInput[]
    createMany?: RunCreateManyTestSuiteRunInputEnvelope
    set?: RunWhereUniqueInput | RunWhereUniqueInput[]
    disconnect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    delete?: RunWhereUniqueInput | RunWhereUniqueInput[]
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    update?: RunUpdateWithWhereUniqueWithoutTestSuiteRunInput | RunUpdateWithWhereUniqueWithoutTestSuiteRunInput[]
    updateMany?: RunUpdateManyWithWhereWithoutTestSuiteRunInput | RunUpdateManyWithWhereWithoutTestSuiteRunInput[]
    deleteMany?: RunScalarWhereInput | RunScalarWhereInput[]
  }

  export type TestAssertionUpdateManyWithoutTestSuiteRunNestedInput = {
    create?: XOR<TestAssertionCreateWithoutTestSuiteRunInput, TestAssertionUncheckedCreateWithoutTestSuiteRunInput> | TestAssertionCreateWithoutTestSuiteRunInput[] | TestAssertionUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutTestSuiteRunInput | TestAssertionCreateOrConnectWithoutTestSuiteRunInput[]
    upsert?: TestAssertionUpsertWithWhereUniqueWithoutTestSuiteRunInput | TestAssertionUpsertWithWhereUniqueWithoutTestSuiteRunInput[]
    createMany?: TestAssertionCreateManyTestSuiteRunInputEnvelope
    set?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    disconnect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    delete?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    update?: TestAssertionUpdateWithWhereUniqueWithoutTestSuiteRunInput | TestAssertionUpdateWithWhereUniqueWithoutTestSuiteRunInput[]
    updateMany?: TestAssertionUpdateManyWithWhereWithoutTestSuiteRunInput | TestAssertionUpdateManyWithWhereWithoutTestSuiteRunInput[]
    deleteMany?: TestAssertionScalarWhereInput | TestAssertionScalarWhereInput[]
  }

  export type RunUncheckedUpdateManyWithoutTestSuiteRunNestedInput = {
    create?: XOR<RunCreateWithoutTestSuiteRunInput, RunUncheckedCreateWithoutTestSuiteRunInput> | RunCreateWithoutTestSuiteRunInput[] | RunUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: RunCreateOrConnectWithoutTestSuiteRunInput | RunCreateOrConnectWithoutTestSuiteRunInput[]
    upsert?: RunUpsertWithWhereUniqueWithoutTestSuiteRunInput | RunUpsertWithWhereUniqueWithoutTestSuiteRunInput[]
    createMany?: RunCreateManyTestSuiteRunInputEnvelope
    set?: RunWhereUniqueInput | RunWhereUniqueInput[]
    disconnect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    delete?: RunWhereUniqueInput | RunWhereUniqueInput[]
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    update?: RunUpdateWithWhereUniqueWithoutTestSuiteRunInput | RunUpdateWithWhereUniqueWithoutTestSuiteRunInput[]
    updateMany?: RunUpdateManyWithWhereWithoutTestSuiteRunInput | RunUpdateManyWithWhereWithoutTestSuiteRunInput[]
    deleteMany?: RunScalarWhereInput | RunScalarWhereInput[]
  }

  export type TestAssertionUncheckedUpdateManyWithoutTestSuiteRunNestedInput = {
    create?: XOR<TestAssertionCreateWithoutTestSuiteRunInput, TestAssertionUncheckedCreateWithoutTestSuiteRunInput> | TestAssertionCreateWithoutTestSuiteRunInput[] | TestAssertionUncheckedCreateWithoutTestSuiteRunInput[]
    connectOrCreate?: TestAssertionCreateOrConnectWithoutTestSuiteRunInput | TestAssertionCreateOrConnectWithoutTestSuiteRunInput[]
    upsert?: TestAssertionUpsertWithWhereUniqueWithoutTestSuiteRunInput | TestAssertionUpsertWithWhereUniqueWithoutTestSuiteRunInput[]
    createMany?: TestAssertionCreateManyTestSuiteRunInputEnvelope
    set?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    disconnect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    delete?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    connect?: TestAssertionWhereUniqueInput | TestAssertionWhereUniqueInput[]
    update?: TestAssertionUpdateWithWhereUniqueWithoutTestSuiteRunInput | TestAssertionUpdateWithWhereUniqueWithoutTestSuiteRunInput[]
    updateMany?: TestAssertionUpdateManyWithWhereWithoutTestSuiteRunInput | TestAssertionUpdateManyWithWhereWithoutTestSuiteRunInput[]
    deleteMany?: TestAssertionScalarWhereInput | TestAssertionScalarWhereInput[]
  }

  export type RunCreateNestedOneWithoutTestAssertionsInput = {
    create?: XOR<RunCreateWithoutTestAssertionsInput, RunUncheckedCreateWithoutTestAssertionsInput>
    connectOrCreate?: RunCreateOrConnectWithoutTestAssertionsInput
    connect?: RunWhereUniqueInput
  }

  export type TestSuiteRunCreateNestedOneWithoutAssertionsInput = {
    create?: XOR<TestSuiteRunCreateWithoutAssertionsInput, TestSuiteRunUncheckedCreateWithoutAssertionsInput>
    connectOrCreate?: TestSuiteRunCreateOrConnectWithoutAssertionsInput
    connect?: TestSuiteRunWhereUniqueInput
  }

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

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

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type RunUpdateOneRequiredWithoutTestAssertionsNestedInput = {
    create?: XOR<RunCreateWithoutTestAssertionsInput, RunUncheckedCreateWithoutTestAssertionsInput>
    connectOrCreate?: RunCreateOrConnectWithoutTestAssertionsInput
    upsert?: RunUpsertWithoutTestAssertionsInput
    connect?: RunWhereUniqueInput
    update?: XOR<XOR<RunUpdateToOneWithWhereWithoutTestAssertionsInput, RunUpdateWithoutTestAssertionsInput>, RunUncheckedUpdateWithoutTestAssertionsInput>
  }

  export type TestSuiteRunUpdateOneRequiredWithoutAssertionsNestedInput = {
    create?: XOR<TestSuiteRunCreateWithoutAssertionsInput, TestSuiteRunUncheckedCreateWithoutAssertionsInput>
    connectOrCreate?: TestSuiteRunCreateOrConnectWithoutAssertionsInput
    upsert?: TestSuiteRunUpsertWithoutAssertionsInput
    connect?: TestSuiteRunWhereUniqueInput
    update?: XOR<XOR<TestSuiteRunUpdateToOneWithWhereWithoutAssertionsInput, TestSuiteRunUpdateWithoutAssertionsInput>, TestSuiteRunUncheckedUpdateWithoutAssertionsInput>
  }

  export type RunCreateNestedManyWithoutWorkflowSnapshotInput = {
    create?: XOR<RunCreateWithoutWorkflowSnapshotInput, RunUncheckedCreateWithoutWorkflowSnapshotInput> | RunCreateWithoutWorkflowSnapshotInput[] | RunUncheckedCreateWithoutWorkflowSnapshotInput[]
    connectOrCreate?: RunCreateOrConnectWithoutWorkflowSnapshotInput | RunCreateOrConnectWithoutWorkflowSnapshotInput[]
    createMany?: RunCreateManyWorkflowSnapshotInputEnvelope
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
  }

  export type RunUncheckedCreateNestedManyWithoutWorkflowSnapshotInput = {
    create?: XOR<RunCreateWithoutWorkflowSnapshotInput, RunUncheckedCreateWithoutWorkflowSnapshotInput> | RunCreateWithoutWorkflowSnapshotInput[] | RunUncheckedCreateWithoutWorkflowSnapshotInput[]
    connectOrCreate?: RunCreateOrConnectWithoutWorkflowSnapshotInput | RunCreateOrConnectWithoutWorkflowSnapshotInput[]
    createMany?: RunCreateManyWorkflowSnapshotInputEnvelope
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
  }

  export type RunUpdateManyWithoutWorkflowSnapshotNestedInput = {
    create?: XOR<RunCreateWithoutWorkflowSnapshotInput, RunUncheckedCreateWithoutWorkflowSnapshotInput> | RunCreateWithoutWorkflowSnapshotInput[] | RunUncheckedCreateWithoutWorkflowSnapshotInput[]
    connectOrCreate?: RunCreateOrConnectWithoutWorkflowSnapshotInput | RunCreateOrConnectWithoutWorkflowSnapshotInput[]
    upsert?: RunUpsertWithWhereUniqueWithoutWorkflowSnapshotInput | RunUpsertWithWhereUniqueWithoutWorkflowSnapshotInput[]
    createMany?: RunCreateManyWorkflowSnapshotInputEnvelope
    set?: RunWhereUniqueInput | RunWhereUniqueInput[]
    disconnect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    delete?: RunWhereUniqueInput | RunWhereUniqueInput[]
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    update?: RunUpdateWithWhereUniqueWithoutWorkflowSnapshotInput | RunUpdateWithWhereUniqueWithoutWorkflowSnapshotInput[]
    updateMany?: RunUpdateManyWithWhereWithoutWorkflowSnapshotInput | RunUpdateManyWithWhereWithoutWorkflowSnapshotInput[]
    deleteMany?: RunScalarWhereInput | RunScalarWhereInput[]
  }

  export type RunUncheckedUpdateManyWithoutWorkflowSnapshotNestedInput = {
    create?: XOR<RunCreateWithoutWorkflowSnapshotInput, RunUncheckedCreateWithoutWorkflowSnapshotInput> | RunCreateWithoutWorkflowSnapshotInput[] | RunUncheckedCreateWithoutWorkflowSnapshotInput[]
    connectOrCreate?: RunCreateOrConnectWithoutWorkflowSnapshotInput | RunCreateOrConnectWithoutWorkflowSnapshotInput[]
    upsert?: RunUpsertWithWhereUniqueWithoutWorkflowSnapshotInput | RunUpsertWithWhereUniqueWithoutWorkflowSnapshotInput[]
    createMany?: RunCreateManyWorkflowSnapshotInputEnvelope
    set?: RunWhereUniqueInput | RunWhereUniqueInput[]
    disconnect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    delete?: RunWhereUniqueInput | RunWhereUniqueInput[]
    connect?: RunWhereUniqueInput | RunWhereUniqueInput[]
    update?: RunUpdateWithWhereUniqueWithoutWorkflowSnapshotInput | RunUpdateWithWhereUniqueWithoutWorkflowSnapshotInput[]
    updateMany?: RunUpdateManyWithWhereWithoutWorkflowSnapshotInput | RunUpdateManyWithWhereWithoutWorkflowSnapshotInput[]
    deleteMany?: RunScalarWhereInput | RunScalarWhereInput[]
  }

  export type AccountCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type SessionCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type UserInviteCreateNestedManyWithoutUserInput = {
    create?: XOR<UserInviteCreateWithoutUserInput, UserInviteUncheckedCreateWithoutUserInput> | UserInviteCreateWithoutUserInput[] | UserInviteUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserInviteCreateOrConnectWithoutUserInput | UserInviteCreateOrConnectWithoutUserInput[]
    createMany?: UserInviteCreateManyUserInputEnvelope
    connect?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
  }

  export type AccountUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type SessionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type UserInviteUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<UserInviteCreateWithoutUserInput, UserInviteUncheckedCreateWithoutUserInput> | UserInviteCreateWithoutUserInput[] | UserInviteUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserInviteCreateOrConnectWithoutUserInput | UserInviteCreateOrConnectWithoutUserInput[]
    createMany?: UserInviteCreateManyUserInputEnvelope
    connect?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
  }

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

  export type AccountUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type SessionUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type UserInviteUpdateManyWithoutUserNestedInput = {
    create?: XOR<UserInviteCreateWithoutUserInput, UserInviteUncheckedCreateWithoutUserInput> | UserInviteCreateWithoutUserInput[] | UserInviteUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserInviteCreateOrConnectWithoutUserInput | UserInviteCreateOrConnectWithoutUserInput[]
    upsert?: UserInviteUpsertWithWhereUniqueWithoutUserInput | UserInviteUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: UserInviteCreateManyUserInputEnvelope
    set?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    disconnect?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    delete?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    connect?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    update?: UserInviteUpdateWithWhereUniqueWithoutUserInput | UserInviteUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: UserInviteUpdateManyWithWhereWithoutUserInput | UserInviteUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: UserInviteScalarWhereInput | UserInviteScalarWhereInput[]
  }

  export type AccountUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type SessionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type UserInviteUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<UserInviteCreateWithoutUserInput, UserInviteUncheckedCreateWithoutUserInput> | UserInviteCreateWithoutUserInput[] | UserInviteUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserInviteCreateOrConnectWithoutUserInput | UserInviteCreateOrConnectWithoutUserInput[]
    upsert?: UserInviteUpsertWithWhereUniqueWithoutUserInput | UserInviteUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: UserInviteCreateManyUserInputEnvelope
    set?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    disconnect?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    delete?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    connect?: UserInviteWhereUniqueInput | UserInviteWhereUniqueInput[]
    update?: UserInviteUpdateWithWhereUniqueWithoutUserInput | UserInviteUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: UserInviteUpdateManyWithWhereWithoutUserInput | UserInviteUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: UserInviteScalarWhereInput | UserInviteScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutInvitesInput = {
    create?: XOR<UserCreateWithoutInvitesInput, UserUncheckedCreateWithoutInvitesInput>
    connectOrCreate?: UserCreateOrConnectWithoutInvitesInput
    connect?: UserWhereUniqueInput
  }

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

  export type UserUpdateOneRequiredWithoutInvitesNestedInput = {
    create?: XOR<UserCreateWithoutInvitesInput, UserUncheckedCreateWithoutInvitesInput>
    connectOrCreate?: UserCreateOrConnectWithoutInvitesInput
    upsert?: UserUpsertWithoutInvitesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutInvitesInput, UserUpdateWithoutInvitesInput>, UserUncheckedUpdateWithoutInvitesInput>
  }

  export type UserCreateNestedOneWithoutAccountsInput = {
    create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutAccountsNestedInput = {
    create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
    upsert?: UserUpsertWithoutAccountsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccountsInput, UserUpdateWithoutAccountsInput>, UserUncheckedUpdateWithoutAccountsInput>
  }

  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 NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

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

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

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

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

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

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

  export type 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 NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedFloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type RunWorkItemCreateWithoutRunInput = {
    workItemId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName?: string | null
    claimToken?: string | null
    claimedBy?: string | null
    claimedAt?: string | null
    availableAt: string
    enqueuedAt: string
    completedAt?: string | null
    failedAt?: string | null
    sourceInstanceId?: string | null
    parentInstanceId?: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson?: string | null
  }

  export type RunWorkItemUncheckedCreateWithoutRunInput = {
    workItemId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName?: string | null
    claimToken?: string | null
    claimedBy?: string | null
    claimedAt?: string | null
    availableAt: string
    enqueuedAt: string
    completedAt?: string | null
    failedAt?: string | null
    sourceInstanceId?: string | null
    parentInstanceId?: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson?: string | null
  }

  export type RunWorkItemCreateOrConnectWithoutRunInput = {
    where: RunWorkItemWhereUniqueInput
    create: XOR<RunWorkItemCreateWithoutRunInput, RunWorkItemUncheckedCreateWithoutRunInput>
  }

  export type RunWorkItemCreateManyRunInputEnvelope = {
    data: RunWorkItemCreateManyRunInput | RunWorkItemCreateManyRunInput[]
    skipDuplicates?: boolean
  }

  export type ExecutionInstanceCreateWithoutRunInput = {
    instanceId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind?: string | null
    activationId?: string | null
    batchId: string
    runIndex: number
    parentInstanceId?: string | null
    parentRunId?: string | null
    workerClaimToken?: string | null
    status: string
    queuedAt?: string | null
    startedAt?: string | null
    finishedAt?: string | null
    updatedAt: string
    itemCount: number
    inputJson?: string | null
    outputJson?: string | null
    errorJson?: string | null
    inputItemIndicesJson?: string | null
    outputItemCount?: number | null
    successfulItemCount?: number | null
    failedItemCount?: number | null
    inputStorageKind?: string | null
    outputStorageKind?: string | null
    inputBytes?: number | null
    outputBytes?: number | null
    inputPreviewJson?: string | null
    outputPreviewJson?: string | null
    inputPayloadRef?: string | null
    outputPayloadRef?: string | null
    inputTruncated?: boolean | null
    outputTruncated?: boolean | null
    usedPinnedOutput?: boolean | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    childRunId?: string | null
  }

  export type ExecutionInstanceUncheckedCreateWithoutRunInput = {
    instanceId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind?: string | null
    activationId?: string | null
    batchId: string
    runIndex: number
    parentInstanceId?: string | null
    parentRunId?: string | null
    workerClaimToken?: string | null
    status: string
    queuedAt?: string | null
    startedAt?: string | null
    finishedAt?: string | null
    updatedAt: string
    itemCount: number
    inputJson?: string | null
    outputJson?: string | null
    errorJson?: string | null
    inputItemIndicesJson?: string | null
    outputItemCount?: number | null
    successfulItemCount?: number | null
    failedItemCount?: number | null
    inputStorageKind?: string | null
    outputStorageKind?: string | null
    inputBytes?: number | null
    outputBytes?: number | null
    inputPreviewJson?: string | null
    outputPreviewJson?: string | null
    inputPayloadRef?: string | null
    outputPayloadRef?: string | null
    inputTruncated?: boolean | null
    outputTruncated?: boolean | null
    usedPinnedOutput?: boolean | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    childRunId?: string | null
  }

  export type ExecutionInstanceCreateOrConnectWithoutRunInput = {
    where: ExecutionInstanceWhereUniqueInput
    create: XOR<ExecutionInstanceCreateWithoutRunInput, ExecutionInstanceUncheckedCreateWithoutRunInput>
  }

  export type ExecutionInstanceCreateManyRunInputEnvelope = {
    data: ExecutionInstanceCreateManyRunInput | ExecutionInstanceCreateManyRunInput[]
    skipDuplicates?: boolean
  }

  export type RunSlotProjectionCreateWithoutRunInput = {
    workflowId: string
    revision: number
    updatedAt: string
    slotStatesJson: string
  }

  export type RunSlotProjectionUncheckedCreateWithoutRunInput = {
    workflowId: string
    revision: number
    updatedAt: string
    slotStatesJson: string
  }

  export type RunSlotProjectionCreateOrConnectWithoutRunInput = {
    where: RunSlotProjectionWhereUniqueInput
    create: XOR<RunSlotProjectionCreateWithoutRunInput, RunSlotProjectionUncheckedCreateWithoutRunInput>
  }

  export type TestSuiteRunCreateWithoutRunsInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
    assertions?: TestAssertionCreateNestedManyWithoutTestSuiteRunInput
  }

  export type TestSuiteRunUncheckedCreateWithoutRunsInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
    assertions?: TestAssertionUncheckedCreateNestedManyWithoutTestSuiteRunInput
  }

  export type TestSuiteRunCreateOrConnectWithoutRunsInput = {
    where: TestSuiteRunWhereUniqueInput
    create: XOR<TestSuiteRunCreateWithoutRunsInput, TestSuiteRunUncheckedCreateWithoutRunsInput>
  }

  export type TestAssertionCreateWithoutRunInput = {
    id: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
    testSuiteRun: TestSuiteRunCreateNestedOneWithoutAssertionsInput
  }

  export type TestAssertionUncheckedCreateWithoutRunInput = {
    id: string
    testSuiteRunId: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
  }

  export type TestAssertionCreateOrConnectWithoutRunInput = {
    where: TestAssertionWhereUniqueInput
    create: XOR<TestAssertionCreateWithoutRunInput, TestAssertionUncheckedCreateWithoutRunInput>
  }

  export type TestAssertionCreateManyRunInputEnvelope = {
    data: TestAssertionCreateManyRunInput | TestAssertionCreateManyRunInput[]
    skipDuplicates?: boolean
  }

  export type WorkflowSnapshotCreateWithoutRunsInput = {
    id: string
    workflowId: string
    snapshotHash: string
    snapshotJson: string
    createdAt: string
  }

  export type WorkflowSnapshotUncheckedCreateWithoutRunsInput = {
    id: string
    workflowId: string
    snapshotHash: string
    snapshotJson: string
    createdAt: string
  }

  export type WorkflowSnapshotCreateOrConnectWithoutRunsInput = {
    where: WorkflowSnapshotWhereUniqueInput
    create: XOR<WorkflowSnapshotCreateWithoutRunsInput, WorkflowSnapshotUncheckedCreateWithoutRunsInput>
  }

  export type RunWorkItemUpsertWithWhereUniqueWithoutRunInput = {
    where: RunWorkItemWhereUniqueInput
    update: XOR<RunWorkItemUpdateWithoutRunInput, RunWorkItemUncheckedUpdateWithoutRunInput>
    create: XOR<RunWorkItemCreateWithoutRunInput, RunWorkItemUncheckedCreateWithoutRunInput>
  }

  export type RunWorkItemUpdateWithWhereUniqueWithoutRunInput = {
    where: RunWorkItemWhereUniqueInput
    data: XOR<RunWorkItemUpdateWithoutRunInput, RunWorkItemUncheckedUpdateWithoutRunInput>
  }

  export type RunWorkItemUpdateManyWithWhereWithoutRunInput = {
    where: RunWorkItemScalarWhereInput
    data: XOR<RunWorkItemUpdateManyMutationInput, RunWorkItemUncheckedUpdateManyWithoutRunInput>
  }

  export type RunWorkItemScalarWhereInput = {
    AND?: RunWorkItemScalarWhereInput | RunWorkItemScalarWhereInput[]
    OR?: RunWorkItemScalarWhereInput[]
    NOT?: RunWorkItemScalarWhereInput | RunWorkItemScalarWhereInput[]
    workItemId?: StringFilter<"RunWorkItem"> | string
    runId?: StringFilter<"RunWorkItem"> | string
    workflowId?: StringFilter<"RunWorkItem"> | string
    status?: StringFilter<"RunWorkItem"> | string
    targetNodeId?: StringFilter<"RunWorkItem"> | string
    batchId?: StringFilter<"RunWorkItem"> | string
    queueName?: StringNullableFilter<"RunWorkItem"> | string | null
    claimToken?: StringNullableFilter<"RunWorkItem"> | string | null
    claimedBy?: StringNullableFilter<"RunWorkItem"> | string | null
    claimedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    availableAt?: StringFilter<"RunWorkItem"> | string
    enqueuedAt?: StringFilter<"RunWorkItem"> | string
    completedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    failedAt?: StringNullableFilter<"RunWorkItem"> | string | null
    sourceInstanceId?: StringNullableFilter<"RunWorkItem"> | string | null
    parentInstanceId?: StringNullableFilter<"RunWorkItem"> | string | null
    itemsIn?: IntFilter<"RunWorkItem"> | number
    inputsByPortJson?: StringFilter<"RunWorkItem"> | string
    errorJson?: StringNullableFilter<"RunWorkItem"> | string | null
  }

  export type ExecutionInstanceUpsertWithWhereUniqueWithoutRunInput = {
    where: ExecutionInstanceWhereUniqueInput
    update: XOR<ExecutionInstanceUpdateWithoutRunInput, ExecutionInstanceUncheckedUpdateWithoutRunInput>
    create: XOR<ExecutionInstanceCreateWithoutRunInput, ExecutionInstanceUncheckedCreateWithoutRunInput>
  }

  export type ExecutionInstanceUpdateWithWhereUniqueWithoutRunInput = {
    where: ExecutionInstanceWhereUniqueInput
    data: XOR<ExecutionInstanceUpdateWithoutRunInput, ExecutionInstanceUncheckedUpdateWithoutRunInput>
  }

  export type ExecutionInstanceUpdateManyWithWhereWithoutRunInput = {
    where: ExecutionInstanceScalarWhereInput
    data: XOR<ExecutionInstanceUpdateManyMutationInput, ExecutionInstanceUncheckedUpdateManyWithoutRunInput>
  }

  export type ExecutionInstanceScalarWhereInput = {
    AND?: ExecutionInstanceScalarWhereInput | ExecutionInstanceScalarWhereInput[]
    OR?: ExecutionInstanceScalarWhereInput[]
    NOT?: ExecutionInstanceScalarWhereInput | ExecutionInstanceScalarWhereInput[]
    instanceId?: StringFilter<"ExecutionInstance"> | string
    runId?: StringFilter<"ExecutionInstance"> | string
    workflowId?: StringFilter<"ExecutionInstance"> | string
    slotNodeId?: StringFilter<"ExecutionInstance"> | string
    workflowNodeId?: StringFilter<"ExecutionInstance"> | string
    kind?: StringFilter<"ExecutionInstance"> | string
    connectionKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    activationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    batchId?: StringFilter<"ExecutionInstance"> | string
    runIndex?: IntFilter<"ExecutionInstance"> | number
    parentInstanceId?: StringNullableFilter<"ExecutionInstance"> | string | null
    parentRunId?: StringNullableFilter<"ExecutionInstance"> | string | null
    workerClaimToken?: StringNullableFilter<"ExecutionInstance"> | string | null
    status?: StringFilter<"ExecutionInstance"> | string
    queuedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    startedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    finishedAt?: StringNullableFilter<"ExecutionInstance"> | string | null
    updatedAt?: StringFilter<"ExecutionInstance"> | string
    itemCount?: IntFilter<"ExecutionInstance"> | number
    inputJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    errorJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputItemIndicesJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    successfulItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    failedItemCount?: IntNullableFilter<"ExecutionInstance"> | number | null
    inputStorageKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputStorageKind?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputBytes?: IntNullableFilter<"ExecutionInstance"> | number | null
    outputBytes?: IntNullableFilter<"ExecutionInstance"> | number | null
    inputPreviewJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputPreviewJson?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputPayloadRef?: StringNullableFilter<"ExecutionInstance"> | string | null
    outputPayloadRef?: StringNullableFilter<"ExecutionInstance"> | string | null
    inputTruncated?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    outputTruncated?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    usedPinnedOutput?: BoolNullableFilter<"ExecutionInstance"> | boolean | null
    iterationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    itemIndex?: IntNullableFilter<"ExecutionInstance"> | number | null
    parentInvocationId?: StringNullableFilter<"ExecutionInstance"> | string | null
    childRunId?: StringNullableFilter<"ExecutionInstance"> | string | null
  }

  export type RunSlotProjectionUpsertWithoutRunInput = {
    update: XOR<RunSlotProjectionUpdateWithoutRunInput, RunSlotProjectionUncheckedUpdateWithoutRunInput>
    create: XOR<RunSlotProjectionCreateWithoutRunInput, RunSlotProjectionUncheckedCreateWithoutRunInput>
    where?: RunSlotProjectionWhereInput
  }

  export type RunSlotProjectionUpdateToOneWithWhereWithoutRunInput = {
    where?: RunSlotProjectionWhereInput
    data: XOR<RunSlotProjectionUpdateWithoutRunInput, RunSlotProjectionUncheckedUpdateWithoutRunInput>
  }

  export type RunSlotProjectionUpdateWithoutRunInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
    slotStatesJson?: StringFieldUpdateOperationsInput | string
  }

  export type RunSlotProjectionUncheckedUpdateWithoutRunInput = {
    workflowId?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    updatedAt?: StringFieldUpdateOperationsInput | string
    slotStatesJson?: StringFieldUpdateOperationsInput | string
  }

  export type TestSuiteRunUpsertWithoutRunsInput = {
    update: XOR<TestSuiteRunUpdateWithoutRunsInput, TestSuiteRunUncheckedUpdateWithoutRunsInput>
    create: XOR<TestSuiteRunCreateWithoutRunsInput, TestSuiteRunUncheckedCreateWithoutRunsInput>
    where?: TestSuiteRunWhereInput
  }

  export type TestSuiteRunUpdateToOneWithWhereWithoutRunsInput = {
    where?: TestSuiteRunWhereInput
    data: XOR<TestSuiteRunUpdateWithoutRunsInput, TestSuiteRunUncheckedUpdateWithoutRunsInput>
  }

  export type TestSuiteRunUpdateWithoutRunsInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    assertions?: TestAssertionUpdateManyWithoutTestSuiteRunNestedInput
  }

  export type TestSuiteRunUncheckedUpdateWithoutRunsInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    assertions?: TestAssertionUncheckedUpdateManyWithoutTestSuiteRunNestedInput
  }

  export type TestAssertionUpsertWithWhereUniqueWithoutRunInput = {
    where: TestAssertionWhereUniqueInput
    update: XOR<TestAssertionUpdateWithoutRunInput, TestAssertionUncheckedUpdateWithoutRunInput>
    create: XOR<TestAssertionCreateWithoutRunInput, TestAssertionUncheckedCreateWithoutRunInput>
  }

  export type TestAssertionUpdateWithWhereUniqueWithoutRunInput = {
    where: TestAssertionWhereUniqueInput
    data: XOR<TestAssertionUpdateWithoutRunInput, TestAssertionUncheckedUpdateWithoutRunInput>
  }

  export type TestAssertionUpdateManyWithWhereWithoutRunInput = {
    where: TestAssertionScalarWhereInput
    data: XOR<TestAssertionUpdateManyMutationInput, TestAssertionUncheckedUpdateManyWithoutRunInput>
  }

  export type TestAssertionScalarWhereInput = {
    AND?: TestAssertionScalarWhereInput | TestAssertionScalarWhereInput[]
    OR?: TestAssertionScalarWhereInput[]
    NOT?: TestAssertionScalarWhereInput | TestAssertionScalarWhereInput[]
    id?: StringFilter<"TestAssertion"> | string
    runId?: StringFilter<"TestAssertion"> | string
    testSuiteRunId?: StringFilter<"TestAssertion"> | string
    workflowId?: StringFilter<"TestAssertion"> | string
    nodeId?: StringFilter<"TestAssertion"> | string
    iterationId?: StringNullableFilter<"TestAssertion"> | string | null
    itemIndex?: IntNullableFilter<"TestAssertion"> | number | null
    name?: StringFilter<"TestAssertion"> | string
    score?: FloatFilter<"TestAssertion"> | number
    passThreshold?: FloatNullableFilter<"TestAssertion"> | number | null
    errored?: BoolFilter<"TestAssertion"> | boolean
    expectedJson?: StringNullableFilter<"TestAssertion"> | string | null
    actualJson?: StringNullableFilter<"TestAssertion"> | string | null
    message?: StringNullableFilter<"TestAssertion"> | string | null
    detailsJson?: StringNullableFilter<"TestAssertion"> | string | null
    createdAt?: StringFilter<"TestAssertion"> | string
  }

  export type WorkflowSnapshotUpsertWithoutRunsInput = {
    update: XOR<WorkflowSnapshotUpdateWithoutRunsInput, WorkflowSnapshotUncheckedUpdateWithoutRunsInput>
    create: XOR<WorkflowSnapshotCreateWithoutRunsInput, WorkflowSnapshotUncheckedCreateWithoutRunsInput>
    where?: WorkflowSnapshotWhereInput
  }

  export type WorkflowSnapshotUpdateToOneWithWhereWithoutRunsInput = {
    where?: WorkflowSnapshotWhereInput
    data: XOR<WorkflowSnapshotUpdateWithoutRunsInput, WorkflowSnapshotUncheckedUpdateWithoutRunsInput>
  }

  export type WorkflowSnapshotUpdateWithoutRunsInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    snapshotHash?: StringFieldUpdateOperationsInput | string
    snapshotJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type WorkflowSnapshotUncheckedUpdateWithoutRunsInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    snapshotHash?: StringFieldUpdateOperationsInput | string
    snapshotJson?: StringFieldUpdateOperationsInput | string
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type RunCreateWithoutWorkItemsInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    executionInstances?: ExecutionInstanceCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionCreateNestedOneWithoutRunInput
    testSuiteRun?: TestSuiteRunCreateNestedOneWithoutRunsInput
    testAssertions?: TestAssertionCreateNestedManyWithoutRunInput
    workflowSnapshot?: WorkflowSnapshotCreateNestedOneWithoutRunsInput
  }

  export type RunUncheckedCreateWithoutWorkItemsInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    executionInstances?: ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput
    testAssertions?: TestAssertionUncheckedCreateNestedManyWithoutRunInput
  }

  export type RunCreateOrConnectWithoutWorkItemsInput = {
    where: RunWhereUniqueInput
    create: XOR<RunCreateWithoutWorkItemsInput, RunUncheckedCreateWithoutWorkItemsInput>
  }

  export type RunUpsertWithoutWorkItemsInput = {
    update: XOR<RunUpdateWithoutWorkItemsInput, RunUncheckedUpdateWithoutWorkItemsInput>
    create: XOR<RunCreateWithoutWorkItemsInput, RunUncheckedCreateWithoutWorkItemsInput>
    where?: RunWhereInput
  }

  export type RunUpdateToOneWithWhereWithoutWorkItemsInput = {
    where?: RunWhereInput
    data: XOR<RunUpdateWithoutWorkItemsInput, RunUncheckedUpdateWithoutWorkItemsInput>
  }

  export type RunUpdateWithoutWorkItemsInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    executionInstances?: ExecutionInstanceUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUpdateOneWithoutRunNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneWithoutRunsNestedInput
    testAssertions?: TestAssertionUpdateManyWithoutRunNestedInput
    workflowSnapshot?: WorkflowSnapshotUpdateOneWithoutRunsNestedInput
  }

  export type RunUncheckedUpdateWithoutWorkItemsInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    executionInstances?: ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput
    testAssertions?: TestAssertionUncheckedUpdateManyWithoutRunNestedInput
  }

  export type RunCreateWithoutExecutionInstancesInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionCreateNestedOneWithoutRunInput
    testSuiteRun?: TestSuiteRunCreateNestedOneWithoutRunsInput
    testAssertions?: TestAssertionCreateNestedManyWithoutRunInput
    workflowSnapshot?: WorkflowSnapshotCreateNestedOneWithoutRunsInput
  }

  export type RunUncheckedCreateWithoutExecutionInstancesInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemUncheckedCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput
    testAssertions?: TestAssertionUncheckedCreateNestedManyWithoutRunInput
  }

  export type RunCreateOrConnectWithoutExecutionInstancesInput = {
    where: RunWhereUniqueInput
    create: XOR<RunCreateWithoutExecutionInstancesInput, RunUncheckedCreateWithoutExecutionInstancesInput>
  }

  export type RunUpsertWithoutExecutionInstancesInput = {
    update: XOR<RunUpdateWithoutExecutionInstancesInput, RunUncheckedUpdateWithoutExecutionInstancesInput>
    create: XOR<RunCreateWithoutExecutionInstancesInput, RunUncheckedCreateWithoutExecutionInstancesInput>
    where?: RunWhereInput
  }

  export type RunUpdateToOneWithWhereWithoutExecutionInstancesInput = {
    where?: RunWhereInput
    data: XOR<RunUpdateWithoutExecutionInstancesInput, RunUncheckedUpdateWithoutExecutionInstancesInput>
  }

  export type RunUpdateWithoutExecutionInstancesInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUpdateOneWithoutRunNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneWithoutRunsNestedInput
    testAssertions?: TestAssertionUpdateManyWithoutRunNestedInput
    workflowSnapshot?: WorkflowSnapshotUpdateOneWithoutRunsNestedInput
  }

  export type RunUncheckedUpdateWithoutExecutionInstancesInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUncheckedUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput
    testAssertions?: TestAssertionUncheckedUpdateManyWithoutRunNestedInput
  }

  export type RunCreateWithoutSlotProjectionInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceCreateNestedManyWithoutRunInput
    testSuiteRun?: TestSuiteRunCreateNestedOneWithoutRunsInput
    testAssertions?: TestAssertionCreateNestedManyWithoutRunInput
    workflowSnapshot?: WorkflowSnapshotCreateNestedOneWithoutRunsInput
  }

  export type RunUncheckedCreateWithoutSlotProjectionInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemUncheckedCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput
    testAssertions?: TestAssertionUncheckedCreateNestedManyWithoutRunInput
  }

  export type RunCreateOrConnectWithoutSlotProjectionInput = {
    where: RunWhereUniqueInput
    create: XOR<RunCreateWithoutSlotProjectionInput, RunUncheckedCreateWithoutSlotProjectionInput>
  }

  export type RunUpsertWithoutSlotProjectionInput = {
    update: XOR<RunUpdateWithoutSlotProjectionInput, RunUncheckedUpdateWithoutSlotProjectionInput>
    create: XOR<RunCreateWithoutSlotProjectionInput, RunUncheckedCreateWithoutSlotProjectionInput>
    where?: RunWhereInput
  }

  export type RunUpdateToOneWithWhereWithoutSlotProjectionInput = {
    where?: RunWhereInput
    data: XOR<RunUpdateWithoutSlotProjectionInput, RunUncheckedUpdateWithoutSlotProjectionInput>
  }

  export type RunUpdateWithoutSlotProjectionInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUpdateManyWithoutRunNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneWithoutRunsNestedInput
    testAssertions?: TestAssertionUpdateManyWithoutRunNestedInput
    workflowSnapshot?: WorkflowSnapshotUpdateOneWithoutRunsNestedInput
  }

  export type RunUncheckedUpdateWithoutSlotProjectionInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUncheckedUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput
    testAssertions?: TestAssertionUncheckedUpdateManyWithoutRunNestedInput
  }

  export type RunCreateWithoutTestSuiteRunInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionCreateNestedOneWithoutRunInput
    testAssertions?: TestAssertionCreateNestedManyWithoutRunInput
    workflowSnapshot?: WorkflowSnapshotCreateNestedOneWithoutRunsInput
  }

  export type RunUncheckedCreateWithoutTestSuiteRunInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemUncheckedCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput
    testAssertions?: TestAssertionUncheckedCreateNestedManyWithoutRunInput
  }

  export type RunCreateOrConnectWithoutTestSuiteRunInput = {
    where: RunWhereUniqueInput
    create: XOR<RunCreateWithoutTestSuiteRunInput, RunUncheckedCreateWithoutTestSuiteRunInput>
  }

  export type RunCreateManyTestSuiteRunInputEnvelope = {
    data: RunCreateManyTestSuiteRunInput | RunCreateManyTestSuiteRunInput[]
    skipDuplicates?: boolean
  }

  export type TestAssertionCreateWithoutTestSuiteRunInput = {
    id: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
    run: RunCreateNestedOneWithoutTestAssertionsInput
  }

  export type TestAssertionUncheckedCreateWithoutTestSuiteRunInput = {
    id: string
    runId: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
  }

  export type TestAssertionCreateOrConnectWithoutTestSuiteRunInput = {
    where: TestAssertionWhereUniqueInput
    create: XOR<TestAssertionCreateWithoutTestSuiteRunInput, TestAssertionUncheckedCreateWithoutTestSuiteRunInput>
  }

  export type TestAssertionCreateManyTestSuiteRunInputEnvelope = {
    data: TestAssertionCreateManyTestSuiteRunInput | TestAssertionCreateManyTestSuiteRunInput[]
    skipDuplicates?: boolean
  }

  export type RunUpsertWithWhereUniqueWithoutTestSuiteRunInput = {
    where: RunWhereUniqueInput
    update: XOR<RunUpdateWithoutTestSuiteRunInput, RunUncheckedUpdateWithoutTestSuiteRunInput>
    create: XOR<RunCreateWithoutTestSuiteRunInput, RunUncheckedCreateWithoutTestSuiteRunInput>
  }

  export type RunUpdateWithWhereUniqueWithoutTestSuiteRunInput = {
    where: RunWhereUniqueInput
    data: XOR<RunUpdateWithoutTestSuiteRunInput, RunUncheckedUpdateWithoutTestSuiteRunInput>
  }

  export type RunUpdateManyWithWhereWithoutTestSuiteRunInput = {
    where: RunScalarWhereInput
    data: XOR<RunUpdateManyMutationInput, RunUncheckedUpdateManyWithoutTestSuiteRunInput>
  }

  export type RunScalarWhereInput = {
    AND?: RunScalarWhereInput | RunScalarWhereInput[]
    OR?: RunScalarWhereInput[]
    NOT?: RunScalarWhereInput | RunScalarWhereInput[]
    runId?: StringFilter<"Run"> | string
    workflowId?: StringFilter<"Run"> | string
    startedAt?: StringFilter<"Run"> | string
    finishedAt?: StringNullableFilter<"Run"> | string | null
    status?: StringFilter<"Run"> | string
    revision?: IntFilter<"Run"> | number
    parentJson?: StringNullableFilter<"Run"> | string | null
    executionOptionsJson?: StringNullableFilter<"Run"> | string | null
    controlJson?: StringNullableFilter<"Run"> | string | null
    workflowSnapshotJson?: StringNullableFilter<"Run"> | string | null
    workflowSnapshotId?: StringNullableFilter<"Run"> | string | null
    policySnapshotJson?: StringNullableFilter<"Run"> | string | null
    engineCountersJson?: StringNullableFilter<"Run"> | string | null
    mutableStateJson?: StringNullableFilter<"Run"> | string | null
    hitlStateJson?: StringNullableFilter<"Run"> | string | null
    outputsByNodeJson?: StringFilter<"Run"> | string
    updatedAt?: StringFilter<"Run"> | string
    testSuiteRunId?: StringNullableFilter<"Run"> | string | null
    testCaseIndex?: IntNullableFilter<"Run"> | number | null
    testCaseLabel?: StringNullableFilter<"Run"> | string | null
    testCaseStatus?: StringNullableFilter<"Run"> | string | null
  }

  export type TestAssertionUpsertWithWhereUniqueWithoutTestSuiteRunInput = {
    where: TestAssertionWhereUniqueInput
    update: XOR<TestAssertionUpdateWithoutTestSuiteRunInput, TestAssertionUncheckedUpdateWithoutTestSuiteRunInput>
    create: XOR<TestAssertionCreateWithoutTestSuiteRunInput, TestAssertionUncheckedCreateWithoutTestSuiteRunInput>
  }

  export type TestAssertionUpdateWithWhereUniqueWithoutTestSuiteRunInput = {
    where: TestAssertionWhereUniqueInput
    data: XOR<TestAssertionUpdateWithoutTestSuiteRunInput, TestAssertionUncheckedUpdateWithoutTestSuiteRunInput>
  }

  export type TestAssertionUpdateManyWithWhereWithoutTestSuiteRunInput = {
    where: TestAssertionScalarWhereInput
    data: XOR<TestAssertionUpdateManyMutationInput, TestAssertionUncheckedUpdateManyWithoutTestSuiteRunInput>
  }

  export type RunCreateWithoutTestAssertionsInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionCreateNestedOneWithoutRunInput
    testSuiteRun?: TestSuiteRunCreateNestedOneWithoutRunsInput
    workflowSnapshot?: WorkflowSnapshotCreateNestedOneWithoutRunsInput
  }

  export type RunUncheckedCreateWithoutTestAssertionsInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemUncheckedCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput
  }

  export type RunCreateOrConnectWithoutTestAssertionsInput = {
    where: RunWhereUniqueInput
    create: XOR<RunCreateWithoutTestAssertionsInput, RunUncheckedCreateWithoutTestAssertionsInput>
  }

  export type TestSuiteRunCreateWithoutAssertionsInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
    runs?: RunCreateNestedManyWithoutTestSuiteRunInput
  }

  export type TestSuiteRunUncheckedCreateWithoutAssertionsInput = {
    id: string
    workflowId: string
    triggerNodeId: string
    triggerNodeName?: string | null
    status: string
    concurrency: number
    startedAt: string
    finishedAt?: string | null
    totalCases?: number
    passedCases?: number
    failedCases?: number
    nodeCoverageJson?: string | null
    errorMessage?: string | null
    updatedAt: string
    runs?: RunUncheckedCreateNestedManyWithoutTestSuiteRunInput
  }

  export type TestSuiteRunCreateOrConnectWithoutAssertionsInput = {
    where: TestSuiteRunWhereUniqueInput
    create: XOR<TestSuiteRunCreateWithoutAssertionsInput, TestSuiteRunUncheckedCreateWithoutAssertionsInput>
  }

  export type RunUpsertWithoutTestAssertionsInput = {
    update: XOR<RunUpdateWithoutTestAssertionsInput, RunUncheckedUpdateWithoutTestAssertionsInput>
    create: XOR<RunCreateWithoutTestAssertionsInput, RunUncheckedCreateWithoutTestAssertionsInput>
    where?: RunWhereInput
  }

  export type RunUpdateToOneWithWhereWithoutTestAssertionsInput = {
    where?: RunWhereInput
    data: XOR<RunUpdateWithoutTestAssertionsInput, RunUncheckedUpdateWithoutTestAssertionsInput>
  }

  export type RunUpdateWithoutTestAssertionsInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUpdateOneWithoutRunNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneWithoutRunsNestedInput
    workflowSnapshot?: WorkflowSnapshotUpdateOneWithoutRunsNestedInput
  }

  export type RunUncheckedUpdateWithoutTestAssertionsInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUncheckedUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput
  }

  export type TestSuiteRunUpsertWithoutAssertionsInput = {
    update: XOR<TestSuiteRunUpdateWithoutAssertionsInput, TestSuiteRunUncheckedUpdateWithoutAssertionsInput>
    create: XOR<TestSuiteRunCreateWithoutAssertionsInput, TestSuiteRunUncheckedCreateWithoutAssertionsInput>
    where?: TestSuiteRunWhereInput
  }

  export type TestSuiteRunUpdateToOneWithWhereWithoutAssertionsInput = {
    where?: TestSuiteRunWhereInput
    data: XOR<TestSuiteRunUpdateWithoutAssertionsInput, TestSuiteRunUncheckedUpdateWithoutAssertionsInput>
  }

  export type TestSuiteRunUpdateWithoutAssertionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    runs?: RunUpdateManyWithoutTestSuiteRunNestedInput
  }

  export type TestSuiteRunUncheckedUpdateWithoutAssertionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    triggerNodeId?: StringFieldUpdateOperationsInput | string
    triggerNodeName?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    concurrency?: IntFieldUpdateOperationsInput | number
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    totalCases?: IntFieldUpdateOperationsInput | number
    passedCases?: IntFieldUpdateOperationsInput | number
    failedCases?: IntFieldUpdateOperationsInput | number
    nodeCoverageJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorMessage?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    runs?: RunUncheckedUpdateManyWithoutTestSuiteRunNestedInput
  }

  export type RunCreateWithoutWorkflowSnapshotInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionCreateNestedOneWithoutRunInput
    testSuiteRun?: TestSuiteRunCreateNestedOneWithoutRunsInput
    testAssertions?: TestAssertionCreateNestedManyWithoutRunInput
  }

  export type RunUncheckedCreateWithoutWorkflowSnapshotInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
    workItems?: RunWorkItemUncheckedCreateNestedManyWithoutRunInput
    executionInstances?: ExecutionInstanceUncheckedCreateNestedManyWithoutRunInput
    slotProjection?: RunSlotProjectionUncheckedCreateNestedOneWithoutRunInput
    testAssertions?: TestAssertionUncheckedCreateNestedManyWithoutRunInput
  }

  export type RunCreateOrConnectWithoutWorkflowSnapshotInput = {
    where: RunWhereUniqueInput
    create: XOR<RunCreateWithoutWorkflowSnapshotInput, RunUncheckedCreateWithoutWorkflowSnapshotInput>
  }

  export type RunCreateManyWorkflowSnapshotInputEnvelope = {
    data: RunCreateManyWorkflowSnapshotInput | RunCreateManyWorkflowSnapshotInput[]
    skipDuplicates?: boolean
  }

  export type RunUpsertWithWhereUniqueWithoutWorkflowSnapshotInput = {
    where: RunWhereUniqueInput
    update: XOR<RunUpdateWithoutWorkflowSnapshotInput, RunUncheckedUpdateWithoutWorkflowSnapshotInput>
    create: XOR<RunCreateWithoutWorkflowSnapshotInput, RunUncheckedCreateWithoutWorkflowSnapshotInput>
  }

  export type RunUpdateWithWhereUniqueWithoutWorkflowSnapshotInput = {
    where: RunWhereUniqueInput
    data: XOR<RunUpdateWithoutWorkflowSnapshotInput, RunUncheckedUpdateWithoutWorkflowSnapshotInput>
  }

  export type RunUpdateManyWithWhereWithoutWorkflowSnapshotInput = {
    where: RunScalarWhereInput
    data: XOR<RunUpdateManyMutationInput, RunUncheckedUpdateManyWithoutWorkflowSnapshotInput>
  }

  export type AccountCreateWithoutUserInput = {
    id?: string
    type?: string
    provider: string
    providerAccountId: string
    password?: string | null
    refresh_token?: string | null
    access_token?: string | null
    expires_at?: number | null
    accessTokenExpiresAt?: Date | string | null
    refreshTokenExpiresAt?: Date | string | null
    token_type?: string | null
    scope?: string | null
    id_token?: string | null
    session_state?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUncheckedCreateWithoutUserInput = {
    id?: string
    type?: string
    provider: string
    providerAccountId: string
    password?: string | null
    refresh_token?: string | null
    access_token?: string | null
    expires_at?: number | null
    accessTokenExpiresAt?: Date | string | null
    refreshTokenExpiresAt?: Date | string | null
    token_type?: string | null
    scope?: string | null
    id_token?: string | null
    session_state?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountCreateOrConnectWithoutUserInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountCreateManyUserInputEnvelope = {
    data: AccountCreateManyUserInput | AccountCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SessionCreateWithoutUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    ipAddress?: string | null
    userAgent?: string | null
  }

  export type SessionUncheckedCreateWithoutUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    ipAddress?: string | null
    userAgent?: string | null
  }

  export type SessionCreateOrConnectWithoutUserInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionCreateManyUserInputEnvelope = {
    data: SessionCreateManyUserInput | SessionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type UserInviteCreateWithoutUserInput = {
    id?: string
    tokenHash: string
    expiresAt: Date | string
    createdAt: Date | string
    revokedAt?: Date | string | null
  }

  export type UserInviteUncheckedCreateWithoutUserInput = {
    id?: string
    tokenHash: string
    expiresAt: Date | string
    createdAt: Date | string
    revokedAt?: Date | string | null
  }

  export type UserInviteCreateOrConnectWithoutUserInput = {
    where: UserInviteWhereUniqueInput
    create: XOR<UserInviteCreateWithoutUserInput, UserInviteUncheckedCreateWithoutUserInput>
  }

  export type UserInviteCreateManyUserInputEnvelope = {
    data: UserInviteCreateManyUserInput | UserInviteCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AccountUpsertWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    update: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountUpdateWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    data: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
  }

  export type AccountUpdateManyWithWhereWithoutUserInput = {
    where: AccountScalarWhereInput
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutUserInput>
  }

  export type AccountScalarWhereInput = {
    AND?: AccountScalarWhereInput | AccountScalarWhereInput[]
    OR?: AccountScalarWhereInput[]
    NOT?: AccountScalarWhereInput | AccountScalarWhereInput[]
    id?: StringFilter<"Account"> | string
    userId?: StringFilter<"Account"> | string
    type?: StringFilter<"Account"> | string
    provider?: StringFilter<"Account"> | string
    providerAccountId?: StringFilter<"Account"> | string
    password?: StringNullableFilter<"Account"> | string | null
    refresh_token?: StringNullableFilter<"Account"> | string | null
    access_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    accessTokenExpiresAt?: DateTimeNullableFilter<"Account"> | Date | string | null
    refreshTokenExpiresAt?: DateTimeNullableFilter<"Account"> | Date | string | null
    token_type?: StringNullableFilter<"Account"> | string | null
    scope?: StringNullableFilter<"Account"> | string | null
    id_token?: StringNullableFilter<"Account"> | string | null
    session_state?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
  }

  export type SessionUpsertWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    update: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionUpdateWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    data: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
  }

  export type SessionUpdateManyWithWhereWithoutUserInput = {
    where: SessionScalarWhereInput
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyWithoutUserInput>
  }

  export type SessionScalarWhereInput = {
    AND?: SessionScalarWhereInput | SessionScalarWhereInput[]
    OR?: SessionScalarWhereInput[]
    NOT?: SessionScalarWhereInput | SessionScalarWhereInput[]
    id?: StringFilter<"Session"> | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    ipAddress?: StringNullableFilter<"Session"> | string | null
    userAgent?: StringNullableFilter<"Session"> | string | null
  }

  export type UserInviteUpsertWithWhereUniqueWithoutUserInput = {
    where: UserInviteWhereUniqueInput
    update: XOR<UserInviteUpdateWithoutUserInput, UserInviteUncheckedUpdateWithoutUserInput>
    create: XOR<UserInviteCreateWithoutUserInput, UserInviteUncheckedCreateWithoutUserInput>
  }

  export type UserInviteUpdateWithWhereUniqueWithoutUserInput = {
    where: UserInviteWhereUniqueInput
    data: XOR<UserInviteUpdateWithoutUserInput, UserInviteUncheckedUpdateWithoutUserInput>
  }

  export type UserInviteUpdateManyWithWhereWithoutUserInput = {
    where: UserInviteScalarWhereInput
    data: XOR<UserInviteUpdateManyMutationInput, UserInviteUncheckedUpdateManyWithoutUserInput>
  }

  export type UserInviteScalarWhereInput = {
    AND?: UserInviteScalarWhereInput | UserInviteScalarWhereInput[]
    OR?: UserInviteScalarWhereInput[]
    NOT?: UserInviteScalarWhereInput | UserInviteScalarWhereInput[]
    id?: StringFilter<"UserInvite"> | string
    userId?: StringFilter<"UserInvite"> | string
    tokenHash?: StringFilter<"UserInvite"> | string
    expiresAt?: DateTimeFilter<"UserInvite"> | Date | string
    createdAt?: DateTimeFilter<"UserInvite"> | Date | string
    revokedAt?: DateTimeNullableFilter<"UserInvite"> | Date | string | null
  }

  export type UserCreateWithoutInvitesInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutInvitesInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutInvitesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutInvitesInput, UserUncheckedCreateWithoutInvitesInput>
  }

  export type UserUpsertWithoutInvitesInput = {
    update: XOR<UserUpdateWithoutInvitesInput, UserUncheckedUpdateWithoutInvitesInput>
    create: XOR<UserCreateWithoutInvitesInput, UserUncheckedCreateWithoutInvitesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutInvitesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutInvitesInput, UserUncheckedUpdateWithoutInvitesInput>
  }

  export type UserUpdateWithoutInvitesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutInvitesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutAccountsInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    sessions?: SessionCreateNestedManyWithoutUserInput
    invites?: UserInviteCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAccountsInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    invites?: UserInviteUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAccountsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
  }

  export type UserUpsertWithoutAccountsInput = {
    update: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
    create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAccountsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
  }

  export type UserUpdateWithoutAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUpdateManyWithoutUserNestedInput
    invites?: UserInviteUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    invites?: UserInviteUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSessionsInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountCreateNestedManyWithoutUserInput
    invites?: UserInviteCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSessionsInput = {
    id?: string
    name?: string | null
    email?: string | null
    emailVerified?: boolean
    image?: string | null
    passwordHash?: string | null
    accountStatus?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    invites?: UserInviteUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSessionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
  }

  export type UserUpsertWithoutSessionsInput = {
    update: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSessionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUpdateManyWithoutUserNestedInput
    invites?: UserInviteUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: BoolFieldUpdateOperationsInput | boolean
    image?: NullableStringFieldUpdateOperationsInput | string | null
    passwordHash?: NullableStringFieldUpdateOperationsInput | string | null
    accountStatus?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    invites?: UserInviteUncheckedUpdateManyWithoutUserNestedInput
  }

  export type RunWorkItemCreateManyRunInput = {
    workItemId: string
    workflowId: string
    status: string
    targetNodeId: string
    batchId: string
    queueName?: string | null
    claimToken?: string | null
    claimedBy?: string | null
    claimedAt?: string | null
    availableAt: string
    enqueuedAt: string
    completedAt?: string | null
    failedAt?: string | null
    sourceInstanceId?: string | null
    parentInstanceId?: string | null
    itemsIn: number
    inputsByPortJson: string
    errorJson?: string | null
  }

  export type ExecutionInstanceCreateManyRunInput = {
    instanceId: string
    workflowId: string
    slotNodeId: string
    workflowNodeId: string
    kind: string
    connectionKind?: string | null
    activationId?: string | null
    batchId: string
    runIndex: number
    parentInstanceId?: string | null
    parentRunId?: string | null
    workerClaimToken?: string | null
    status: string
    queuedAt?: string | null
    startedAt?: string | null
    finishedAt?: string | null
    updatedAt: string
    itemCount: number
    inputJson?: string | null
    outputJson?: string | null
    errorJson?: string | null
    inputItemIndicesJson?: string | null
    outputItemCount?: number | null
    successfulItemCount?: number | null
    failedItemCount?: number | null
    inputStorageKind?: string | null
    outputStorageKind?: string | null
    inputBytes?: number | null
    outputBytes?: number | null
    inputPreviewJson?: string | null
    outputPreviewJson?: string | null
    inputPayloadRef?: string | null
    outputPayloadRef?: string | null
    inputTruncated?: boolean | null
    outputTruncated?: boolean | null
    usedPinnedOutput?: boolean | null
    iterationId?: string | null
    itemIndex?: number | null
    parentInvocationId?: string | null
    childRunId?: string | null
  }

  export type TestAssertionCreateManyRunInput = {
    id: string
    testSuiteRunId: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
  }

  export type RunWorkItemUpdateWithoutRunInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunWorkItemUncheckedUpdateWithoutRunInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RunWorkItemUncheckedUpdateManyWithoutRunInput = {
    workItemId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    targetNodeId?: StringFieldUpdateOperationsInput | string
    batchId?: StringFieldUpdateOperationsInput | string
    queueName?: NullableStringFieldUpdateOperationsInput | string | null
    claimToken?: NullableStringFieldUpdateOperationsInput | string | null
    claimedBy?: NullableStringFieldUpdateOperationsInput | string | null
    claimedAt?: NullableStringFieldUpdateOperationsInput | string | null
    availableAt?: StringFieldUpdateOperationsInput | string
    enqueuedAt?: StringFieldUpdateOperationsInput | string
    completedAt?: NullableStringFieldUpdateOperationsInput | string | null
    failedAt?: NullableStringFieldUpdateOperationsInput | string | null
    sourceInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    itemsIn?: IntFieldUpdateOperationsInput | number
    inputsByPortJson?: StringFieldUpdateOperationsInput | string
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExecutionInstanceUpdateWithoutRunInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExecutionInstanceUncheckedUpdateWithoutRunInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ExecutionInstanceUncheckedUpdateManyWithoutRunInput = {
    instanceId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    slotNodeId?: StringFieldUpdateOperationsInput | string
    workflowNodeId?: StringFieldUpdateOperationsInput | string
    kind?: StringFieldUpdateOperationsInput | string
    connectionKind?: NullableStringFieldUpdateOperationsInput | string | null
    activationId?: NullableStringFieldUpdateOperationsInput | string | null
    batchId?: StringFieldUpdateOperationsInput | string
    runIndex?: IntFieldUpdateOperationsInput | number
    parentInstanceId?: NullableStringFieldUpdateOperationsInput | string | null
    parentRunId?: NullableStringFieldUpdateOperationsInput | string | null
    workerClaimToken?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    queuedAt?: NullableStringFieldUpdateOperationsInput | string | null
    startedAt?: NullableStringFieldUpdateOperationsInput | string | null
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: StringFieldUpdateOperationsInput | string
    itemCount?: IntFieldUpdateOperationsInput | number
    inputJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputJson?: NullableStringFieldUpdateOperationsInput | string | null
    errorJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputItemIndicesJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    successfulItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    failedItemCount?: NullableIntFieldUpdateOperationsInput | number | null
    inputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    outputStorageKind?: NullableStringFieldUpdateOperationsInput | string | null
    inputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    outputBytes?: NullableIntFieldUpdateOperationsInput | number | null
    inputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputPreviewJson?: NullableStringFieldUpdateOperationsInput | string | null
    inputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    outputPayloadRef?: NullableStringFieldUpdateOperationsInput | string | null
    inputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    outputTruncated?: NullableBoolFieldUpdateOperationsInput | boolean | null
    usedPinnedOutput?: NullableBoolFieldUpdateOperationsInput | boolean | null
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    parentInvocationId?: NullableStringFieldUpdateOperationsInput | string | null
    childRunId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TestAssertionUpdateWithoutRunInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    testSuiteRun?: TestSuiteRunUpdateOneRequiredWithoutAssertionsNestedInput
  }

  export type TestAssertionUncheckedUpdateWithoutRunInput = {
    id?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type TestAssertionUncheckedUpdateManyWithoutRunInput = {
    id?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type RunCreateManyTestSuiteRunInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    workflowSnapshotId?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
  }

  export type TestAssertionCreateManyTestSuiteRunInput = {
    id: string
    runId: string
    workflowId: string
    nodeId: string
    iterationId?: string | null
    itemIndex?: number | null
    name: string
    score: number
    passThreshold?: number | null
    errored?: boolean
    expectedJson?: string | null
    actualJson?: string | null
    message?: string | null
    detailsJson?: string | null
    createdAt: string
  }

  export type RunUpdateWithoutTestSuiteRunInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUpdateOneWithoutRunNestedInput
    testAssertions?: TestAssertionUpdateManyWithoutRunNestedInput
    workflowSnapshot?: WorkflowSnapshotUpdateOneWithoutRunsNestedInput
  }

  export type RunUncheckedUpdateWithoutTestSuiteRunInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUncheckedUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput
    testAssertions?: TestAssertionUncheckedUpdateManyWithoutRunNestedInput
  }

  export type RunUncheckedUpdateManyWithoutTestSuiteRunInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotId?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TestAssertionUpdateWithoutTestSuiteRunInput = {
    id?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
    run?: RunUpdateOneRequiredWithoutTestAssertionsNestedInput
  }

  export type TestAssertionUncheckedUpdateWithoutTestSuiteRunInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type TestAssertionUncheckedUpdateManyWithoutTestSuiteRunInput = {
    id?: StringFieldUpdateOperationsInput | string
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    nodeId?: StringFieldUpdateOperationsInput | string
    iterationId?: NullableStringFieldUpdateOperationsInput | string | null
    itemIndex?: NullableIntFieldUpdateOperationsInput | number | null
    name?: StringFieldUpdateOperationsInput | string
    score?: FloatFieldUpdateOperationsInput | number
    passThreshold?: NullableFloatFieldUpdateOperationsInput | number | null
    errored?: BoolFieldUpdateOperationsInput | boolean
    expectedJson?: NullableStringFieldUpdateOperationsInput | string | null
    actualJson?: NullableStringFieldUpdateOperationsInput | string | null
    message?: NullableStringFieldUpdateOperationsInput | string | null
    detailsJson?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: StringFieldUpdateOperationsInput | string
  }

  export type RunCreateManyWorkflowSnapshotInput = {
    runId: string
    workflowId: string
    startedAt: string
    finishedAt?: string | null
    status: string
    revision?: number
    parentJson?: string | null
    executionOptionsJson?: string | null
    controlJson?: string | null
    workflowSnapshotJson?: string | null
    policySnapshotJson?: string | null
    engineCountersJson?: string | null
    mutableStateJson?: string | null
    hitlStateJson?: string | null
    outputsByNodeJson: string
    updatedAt: string
    testSuiteRunId?: string | null
    testCaseIndex?: number | null
    testCaseLabel?: string | null
    testCaseStatus?: string | null
  }

  export type RunUpdateWithoutWorkflowSnapshotInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUpdateOneWithoutRunNestedInput
    testSuiteRun?: TestSuiteRunUpdateOneWithoutRunsNestedInput
    testAssertions?: TestAssertionUpdateManyWithoutRunNestedInput
  }

  export type RunUncheckedUpdateWithoutWorkflowSnapshotInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
    workItems?: RunWorkItemUncheckedUpdateManyWithoutRunNestedInput
    executionInstances?: ExecutionInstanceUncheckedUpdateManyWithoutRunNestedInput
    slotProjection?: RunSlotProjectionUncheckedUpdateOneWithoutRunNestedInput
    testAssertions?: TestAssertionUncheckedUpdateManyWithoutRunNestedInput
  }

  export type RunUncheckedUpdateManyWithoutWorkflowSnapshotInput = {
    runId?: StringFieldUpdateOperationsInput | string
    workflowId?: StringFieldUpdateOperationsInput | string
    startedAt?: StringFieldUpdateOperationsInput | string
    finishedAt?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    revision?: IntFieldUpdateOperationsInput | number
    parentJson?: NullableStringFieldUpdateOperationsInput | string | null
    executionOptionsJson?: NullableStringFieldUpdateOperationsInput | string | null
    controlJson?: NullableStringFieldUpdateOperationsInput | string | null
    workflowSnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    policySnapshotJson?: NullableStringFieldUpdateOperationsInput | string | null
    engineCountersJson?: NullableStringFieldUpdateOperationsInput | string | null
    mutableStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    hitlStateJson?: NullableStringFieldUpdateOperationsInput | string | null
    outputsByNodeJson?: StringFieldUpdateOperationsInput | string
    updatedAt?: StringFieldUpdateOperationsInput | string
    testSuiteRunId?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseIndex?: NullableIntFieldUpdateOperationsInput | number | null
    testCaseLabel?: NullableStringFieldUpdateOperationsInput | string | null
    testCaseStatus?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AccountCreateManyUserInput = {
    id?: string
    type?: string
    provider: string
    providerAccountId: string
    password?: string | null
    refresh_token?: string | null
    access_token?: string | null
    expires_at?: number | null
    accessTokenExpiresAt?: Date | string | null
    refreshTokenExpiresAt?: Date | string | null
    token_type?: string | null
    scope?: string | null
    id_token?: string | null
    session_state?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionCreateManyUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    ipAddress?: string | null
    userAgent?: string | null
  }

  export type UserInviteCreateManyUserInput = {
    id?: string
    tokenHash: string
    expiresAt: Date | string
    createdAt: Date | string
    revokedAt?: Date | string | null
  }

  export type AccountUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    provider?: StringFieldUpdateOperationsInput | string
    providerAccountId?: StringFieldUpdateOperationsInput | string
    password?: NullableStringFieldUpdateOperationsInput | string | null
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    accessTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    refreshTokenExpiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    session_state?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserInviteUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UserInviteUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UserInviteUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}