import { r as AppConfig } from "./CodemationAppContext-CA4xzGA6.js";
import { t as NormalizedCodemationConfig } from "./CodemationConfigNormalizer-CvZ1Sb3a.js";
import { AnyNull, AnyNullClass, DbNull, DbNullClass, Decimal, JsonNull, JsonNullClass, NullTypes as NullTypes$1, ObjectEnumValue, PrismaClientInitializationError, PrismaClientKnownRequestError, PrismaClientRustPanicError, PrismaClientUnknownRequestError, PrismaClientValidationError, RawValue, Sql, Value, empty, isAnyNull, isDbNull, isJsonNull, isObjectEnumValue, join, raw, sql as sqltag } from "@prisma/client-runtime-utils";

//#region prisma-generated/prisma-postgresql-client/runtime/client.d.ts
declare namespace client_d_exports {
  export { Action, Aggregate, AllModelsToStringIndex, AnyNull, AnyNullClass, ApplyOmit, Args, Args_3, BaseDMMF, Bytes, Call, Cast, ClientArg, ClientArgs, ClientBuiltInProp, ClientOptionDef, ClientOtherOps, Compute, ComputeDeep, Count, DMMF, DbNull, DbNullClass, Debug, Decimal, DecimalJsLike, DefaultArgs, DefaultSelection, DevTypeMapDef, DevTypeMapFnDef, DynamicClientExtensionArgs, DynamicClientExtensionThis, DynamicClientExtensionThisBuiltin, DynamicModelExtensionArgs, DynamicModelExtensionFluentApi, DynamicModelExtensionFnResult, DynamicModelExtensionFnResultBase, DynamicModelExtensionFnResultNull, DynamicModelExtensionOperationFn, DynamicModelExtensionThis, DynamicQueryExtensionArgs, DynamicQueryExtensionCb, DynamicQueryExtensionCbArgs, DynamicQueryExtensionCbArgsArgs, DynamicResultExtensionArgs, DynamicResultExtensionData, DynamicResultExtensionNeeds, EmptyToUnknown, Equals, Exact, ExtendsHook, ExtensionArgs, Extensions, ExtractGlobalOmit, FieldRef$1 as FieldRef, Fn, GetAggregateResult, GetBatchResult, GetCountResult, GetFindResult, GetGroupByResult, GetOmit, GetPayloadResult, GetPayloadResultExtensionKeys, GetPayloadResultExtensionObject, GetPrismaClientConfig, GetResult, GetSelect, ITXClientDenyList, InputJsonArray, InputJsonObject, InputJsonValue, InternalArgs, JsArgs, JsInputValue, JsOutputValue, JsPromise, JsonArray, JsonBatchQuery, JsonConvertible, JsonNull, JsonNullClass, JsonObject, JsonQuery, JsonValue, MergeExtArgs, ModelArg, ModelArgs, ModelKey, ModelQueryOptionsCb, ModelQueryOptionsCbArgs, NameArgs, Narrow, Narrowable, NeverToUnknown, NullTypes$1 as NullTypes, ObjectEnumValue, Omission, Omit_2 as Omit, OmitValue, Operation, OperationPayload, Optional, OptionalFlat$1 as OptionalFlat, OptionalKeys, Or$1 as Or, Param, PatchFlat, Path, Payload, PayloadToResult, Pick_2 as Pick, PrismaClientInitializationError, PrismaClientKnownRequestError, PrismaClientOptions, PrismaClientRustPanicError, PrismaClientUnknownRequestError, PrismaClientValidationError, PrismaPromise, PrivateResultType, Public, QueryOptions, QueryOptionsCb, QueryOptionsCbArgs, RawParameters, RawQueryArgs, RawValue, ReadonlyDeep, Record_2 as Record, RenameAndNestPayloadKeys, RequiredExtensionArgs, RequiredKeys$1 as RequiredKeys, Result, ResultArg, ResultArgs, ResultArgsFieldCompute, ResultFieldDefinition, Result_2, Return, RuntimeDataModel, Select, SelectField, SelectablePayloadFields, Selection_2 as Selection, Sql, SqlCommenterContext, SqlCommenterPlugin, SqlCommenterQueryInfo, SqlCommenterSingleQueryInfo, SqlCommenterTags, SqlDriverAdapterFactory, ToTuple, TypeMapCbDef, TypeMapDef, TypedSql, Types, UnknownTypedSql, UnwrapPayload, UnwrapPromise, UnwrapTuple, RequiredExtensionArgs as UserArgs, Value, createParam, defineDmmfProperty, deserializeJsonObject, deserializeRawResult, dmmfToRuntimeDataModel, empty, getPrismaClient, getRuntime, isAnyNull, isDbNull, isJsonNull, isObjectEnumValue, isTypedSql, itxClientDenyList, join, makeStrictEnum, makeTypedQueryFactory, raw, serializeJsonQuery, skip, sqltag, warnOnce };
}
/**
 * @param this
 */
declare function $extends(this: Client, extension: ExtensionArgs | ((client: Client) => Client)): Client;

/**
 * Used by `@prisma/extension-accelerate` until we migrate it to a better API.
 */
declare interface AccelerateEngineConfig extends EngineConfig {
  /**
   * Allows Accelerate to use runtime utilities from the client. These are
   * necessary for `@prisma/extension-accelerate` to function correctly.
   * See <https://github.com/prisma/prisma-extension-accelerate/blob/b6ffa853f038780f5ab2fc01bff584ca251f645b/src/extension.ts#L518>
   */
  accelerateUtils: {
    resolveDatasourceUrl: () => string;
  };
}

/**
 * A stripped down interface of `fetch` that `@prisma/extension-accelerate`
 * relies on. It must be in sync with the corresponding definition in the
 * Accelerate extension.
 *
 * This is the actual interface exposed by the extension. We can't use the
 * custom fetch function provided by it as normal fetch because the API is
 * different. Notably, `headers` must be an object and not a `Headers`
 * instance, and `url` must be a `string` and not a `URL`.
 *
 * The return type is `Response` but we can't specify this in an exported type
 * because it would end up referencing external types from `@types/node` or DOM
 * which can fail typechecking depending on TypeScript configuration in a user's
 * project.
 */
declare type AccelerateExtensionFetch = (url: string, options: {
  body?: string;
  method?: string;
  headers: Record<string, string>;
}) => Promise<unknown>;
declare type AccelerateExtensionFetchDecorator = (fetch: AccelerateExtensionFetch) => AccelerateExtensionFetch;
declare type Action = keyof typeof DMMF_2.ModelAction | 'executeRaw' | 'queryRaw' | 'runCommandRaw';
declare type ActiveConnectorType = Exclude<ConnectorType, 'postgres' | 'prisma+postgres'>;

/**
 * An interface that exposes some basic information about the
 * adapter like its name and provider type.
 */
declare interface AdapterInfo {
  readonly provider: Provider;
  readonly adapterName: (typeof officialPrismaAdapters)[number] | (string & {});
}
declare type Aggregate = '_count' | '_max' | '_min' | '_avg' | '_sum';
declare type AllModelsToStringIndex<TypeMap extends TypeMapDef, Args$1 extends Record<string, any>, K$1 extends PropertyKey> = Args$1 extends { [P in K$1]: {
  $allModels: infer AllModels;
} } ? { [P in K$1]: Record<TypeMap['meta']['modelProps'], AllModels> } : {};
declare type ApplyOmit<T$1, OmitConfig> = Compute<{ [K in keyof T$1 as OmitValue<OmitConfig, K> extends true ? never : K]: T$1[K] }>;
declare type Args<T$1, F extends Operation> = T$1 extends {
  [K: symbol]: {
    types: {
      operations: { [K in F]: {
        args: any;
      } };
    };
  };
} ? T$1[symbol]['types']['operations'][F]['args'] : any;
declare type Args_3<T$1, F extends Operation> = Args<T$1, F>;
declare type ArgScalarType = 'string' | 'int' | 'bigint' | 'float' | 'decimal' | 'boolean' | 'enum' | 'uuid' | 'json' | 'datetime' | 'bytes' | 'unknown';
declare type ArgType = {
  scalarType: ArgScalarType;
  dbType?: string;
  arity: Arity;
};
declare type Arity = 'scalar' | 'list';

/**
 * Attributes is a map from string to attribute values.
 *
 * Note: only the own enumerable keys are counted as valid attribute keys.
 */
declare interface Attributes {
  [attributeKey: string]: AttributeValue | undefined;
}

/**
 * Attribute values may be any non-nullish primitive value except an object.
 *
 * null or undefined attribute values are invalid and will result in undefined behavior.
 */
declare type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
declare type BaseDMMF = {
  readonly datamodel: Omit<DMMF_2.Datamodel, 'indexes'>;
};
declare type BatchArgs = {
  queries: BatchQuery[];
  transaction?: {
    isolationLevel?: IsolationLevel_2;
  };
};
declare type BatchInternalParams = {
  requests: RequestParams[];
  customDataProxyFetch?: AccelerateExtensionFetchDecorator;
};
declare type BatchQuery = {
  model: string | undefined;
  operation: string;
  args: JsArgs | RawQueryArgs;
};
declare type BatchQueryEngineResult<T$1> = QueryEngineResultData<T$1> | Error;
declare type BatchQueryOptionsCb = (args: BatchQueryOptionsCbArgs) => Promise<any>;
declare type BatchQueryOptionsCbArgs = {
  args: BatchArgs;
  query: (args: BatchArgs, __internalParams?: BatchInternalParams) => Promise<unknown[]>;
  __internalParams: BatchInternalParams;
};
declare type BatchResponse = MultiBatchResponse | CompactedBatchResponse;
declare type BatchTransactionOptions = {
  isolationLevel?: Transaction_2.IsolationLevel;
};

/**
 * Equivalent to `Uint8Array` before TypeScript 5.7, and `Uint8Array<ArrayBuffer>` in TypeScript 5.7 and beyond.
 */
declare type Bytes = ReturnType<Uint8Array['slice']>;
declare type Call<F extends Fn, P$1> = (F & {
  params: P$1;
})['returns'];
declare interface CallSite {
  getLocation(): LocationInFile | null;
}
declare type Cast<A, W> = A extends W ? A : W;
declare type Client = ReturnType<typeof getPrismaClient> extends (new (optionsArg: PrismaClientOptions) => infer T) ? T : never;
declare type ClientArg = { [MethodName in string]: unknown };
declare type ClientArgs = {
  client: ClientArg;
};
declare type ClientBuiltInProp = keyof DynamicClientExtensionThisBuiltin<never, never, never>;
declare type ClientOptionDef = undefined | { [K in string]: any };
declare type ClientOtherOps = {
  $queryRaw<T$1 = unknown>(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise<T$1>;
  $queryRawTyped<T$1>(query: TypedSql<unknown[], T$1>): PrismaPromise<T$1[]>;
  $queryRawUnsafe<T$1 = unknown>(query: string, ...values: any[]): PrismaPromise<T$1>;
  $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise<number>;
  $executeRawUnsafe(query: string, ...values: any[]): PrismaPromise<number>;
  $runCommandRaw(command: InputJsonObject): PrismaPromise<JsonObject>;
};
declare type ColumnType = (typeof ColumnTypeEnum)[keyof typeof ColumnTypeEnum];
declare const ColumnTypeEnum: {
  readonly Int32: 0;
  readonly Int64: 1;
  readonly Float: 2;
  readonly Double: 3;
  readonly Numeric: 4;
  readonly Boolean: 5;
  readonly Character: 6;
  readonly Text: 7;
  readonly Date: 8;
  readonly Time: 9;
  readonly DateTime: 10;
  readonly Json: 11;
  readonly Enum: 12;
  readonly Bytes: 13;
  readonly Set: 14;
  readonly Uuid: 15;
  readonly Int32Array: 64;
  readonly Int64Array: 65;
  readonly FloatArray: 66;
  readonly DoubleArray: 67;
  readonly NumericArray: 68;
  readonly BooleanArray: 69;
  readonly CharacterArray: 70;
  readonly TextArray: 71;
  readonly DateArray: 72;
  readonly TimeArray: 73;
  readonly DateTimeArray: 74;
  readonly JsonArray: 75;
  readonly EnumArray: 76;
  readonly BytesArray: 77;
  readonly UuidArray: 78;
  readonly UnknownNumber: 128;
};
declare type CompactedBatchResponse = {
  type: 'compacted';
  plan: QueryPlanNode;
  arguments: Record<string, {}>[];
  nestedSelection: string[];
  keys: string[];
  expectNonEmpty: boolean;
};
declare type CompilerWasmLoadingConfig = {
  /**
   * WASM-bindgen runtime for corresponding module
   */
  getRuntime: () => Promise<{
    __wbg_set_wasm(exports: unknown): void;
    QueryCompiler: QueryCompilerConstructor;
  }>;
  /**
   * Loads the raw wasm module for the wasm compiler engine. This configuration is
   * generated specifically for each type of client, eg. Node.js client and Edge
   * clients will have different implementations.
   * @remarks this is a callback on purpose, we only load the wasm if needed.
   * @remarks only used by ClientEngine
   */
  getQueryCompilerWasmModule: () => Promise<unknown>;
  importName: string;
};
declare type Compute<T$1> = T$1 extends Function ? T$1 : { [K in keyof T$1]: T$1[K] } & unknown;
declare type ComputeDeep<T$1> = T$1 extends Function ? T$1 : { [K in keyof T$1]: ComputeDeep<T$1[K]> } & unknown;
declare type ComputedField = {
  name: string;
  needs: string[];
  compute: ResultArgsFieldCompute;
};
declare type ComputedFieldsMap = {
  [fieldName: string]: ComputedField;
};
declare type ConnectionInfo = {
  schemaName?: string;
  maxBindValues?: number;
  supportsRelationJoins: boolean;
};
declare type ConnectorType = 'mysql' | 'mongodb' | 'sqlite' | 'postgresql' | 'postgres' | 'prisma+postgres' | 'sqlserver' | 'cockroachdb';
declare interface Context {
  /**
   * Get a value from the context.
   *
   * @param key key which identifies a context value
   */
  getValue(key: symbol): unknown;
  /**
   * Create a new context which inherits from this context and has
   * the given key set to the given value.
   *
   * @param key context key for which to set the value
   * @param value value to set for the given key
   */
  setValue(key: symbol, value: unknown): Context;
  /**
   * Return a new context which inherits from this context but does
   * not contain a value for the given key.
   *
   * @param key context key for which to clear a value
   */
  deleteValue(key: symbol): Context;
}
declare type Context_2<T$1> = T$1 extends {
  [K: symbol]: {
    ctx: infer C;
  };
} ? C & T$1 & {
  /**
   * @deprecated Use `$name` instead.
   */
  name?: string;
  $name?: string;
  $parent?: unknown;
} : T$1 & {
  /**
   * @deprecated Use `$name` instead.
   */
  name?: string;
  $name?: string;
  $parent?: unknown;
};
declare type Count<O$1> = { [K in keyof O$1]: Count<number> } & {};
declare function createParam(name: string): Param<unknown, string>;
declare class DataLoader<T$1 = unknown> {
  private options;
  batches: {
    [key: string]: Job[];
  };
  private tickActive;
  constructor(options: DataLoaderOptions<T$1>);
  request(request: T$1): Promise<any>;
  private dispatchBatches;
  get [Symbol.toStringTag](): string;
}
declare type DataLoaderOptions<T$1> = {
  singleLoader: (request: T$1) => Promise<any>;
  batchLoader: (request: T$1[]) => Promise<any[]>;
  batchBy: (request: T$1) => string | undefined;
  batchOrder: (requestA: T$1, requestB: T$1) => number;
};
declare type Datamodel = ReadonlyDeep_2<{
  models: Model[];
  enums: DatamodelEnum[];
  types: Model[];
  indexes: Index[];
}>;
declare type DatamodelEnum = ReadonlyDeep_2<{
  name: string;
  values: EnumValue[];
  dbName?: string | null;
  documentation?: string;
}>;
declare function datamodelEnumToSchemaEnum(datamodelEnum: DatamodelEnum): SchemaEnum;
declare type DataRule = {
  type: 'rowCountEq';
  args: number;
} | {
  type: 'rowCountNeq';
  args: number;
} | {
  type: 'affectedRowCountEq';
  args: number;
} | {
  type: 'never';
};
declare const Debug: typeof debugCreate & {
  enable(namespace: any): void;
  disable(): any;
  enabled(namespace: string): boolean;
  log: (...args: string[]) => void;
  formatters: {};
};
/**
 * Create a new debug instance with the given namespace.
 *
 * @example
 * ```ts
 * import Debug from '@prisma/debug'
 * const debug = Debug('prisma:client')
 * debug('Hello World')
 * ```
 */
declare function debugCreate(namespace: string): ((...args: any[]) => void) & {
  color: string;
  enabled: boolean;
  namespace: string;
  log: (...args: string[]) => void;
  extend: () => void;
};
/**
 * Interface for any Decimal.js-like library
 * Allows us to accept Decimal.js from different
 * versions and some compatible alternatives
 */
declare interface DecimalJsLike {
  d: number[];
  e: number;
  s: number;
  toFixed(): string;
}
declare type DefaultArgs = InternalArgs<{}, {}, {}, {}>;
declare type DefaultSelection<Payload$1 extends OperationPayload, Args$1 = {}, GlobalOmitOptions$1 = {}> = Args$1 extends {
  omit: infer LocalOmit;
} ? ApplyOmit<UnwrapPayload<{
  default: Payload$1;
}>['default'], PatchFlat<LocalOmit, ExtractGlobalOmit<GlobalOmitOptions$1, Uncapitalize<Payload$1['name']>>>> : ApplyOmit<UnwrapPayload<{
  default: Payload$1;
}>['default'], ExtractGlobalOmit<GlobalOmitOptions$1, Uncapitalize<Payload$1['name']>>>;
declare function defineDmmfProperty(target: object, runtimeDataModel: RuntimeDataModel): void;
declare function defineExtension(ext: ExtensionArgs | ((client: Client) => Client)): (client: Client) => Client;
declare const denylist: readonly ["$connect", "$disconnect", "$on", "$use", "$extends"];
declare type Deprecation = ReadonlyDeep_2<{
  sinceVersion: string;
  reason: string;
  plannedRemovalVersion?: string;
}>;
declare type DeserializedResponse = Array<Record<string, unknown>>;
declare function deserializeJsonObject(result: unknown): unknown;
declare function deserializeRawResult(response: RawResponse): DeserializedResponse;
declare type DevTypeMapDef = {
  meta: {
    modelProps: string;
  };
  model: { [Model in PropertyKey]: { [Operation in PropertyKey]: DevTypeMapFnDef } };
  other: { [Operation in PropertyKey]: DevTypeMapFnDef };
};
declare type DevTypeMapFnDef = {
  args: any;
  result: any;
  payload: OperationPayload;
};
declare namespace DMMF {
  export { datamodelEnumToSchemaEnum, Document_2 as Document, Mappings, OtherOperationMappings, DatamodelEnum, SchemaEnum, EnumValue, Datamodel, uniqueIndex, PrimaryKey, Model, FieldKind, FieldNamespace, FieldLocation, Field, FieldDefault, FieldDefaultScalar, Index, IndexType, IndexField, SortOrder$1 as SortOrder, Schema, Query, QueryOutput, TypeRef, InputTypeRef, SchemaArg, OutputType, SchemaField, OutputTypeRef, Deprecation, InputType, FieldRefType, FieldRefAllowType, ModelMapping, ModelAction, ReadonlyDeep_2 as ReadonlyDeep };
}
declare namespace DMMF_2 {
  export { datamodelEnumToSchemaEnum, Document_2 as Document, Mappings, OtherOperationMappings, DatamodelEnum, SchemaEnum, EnumValue, Datamodel, uniqueIndex, PrimaryKey, Model, FieldKind, FieldNamespace, FieldLocation, Field, FieldDefault, FieldDefaultScalar, Index, IndexType, IndexField, SortOrder$1 as SortOrder, Schema, Query, QueryOutput, TypeRef, InputTypeRef, SchemaArg, OutputType, SchemaField, OutputTypeRef, Deprecation, InputType, FieldRefType, FieldRefAllowType, ModelMapping, ModelAction, ReadonlyDeep_2 as ReadonlyDeep };
}
declare function dmmfToRuntimeDataModel(dmmfDataModel: DMMF_2.Datamodel): RuntimeDataModel;
declare type Document_2 = ReadonlyDeep_2<{
  datamodel: Datamodel;
  schema: Schema;
  mappings: Mappings;
}>;

/**
 * A generic driver adapter factory that allows the user to instantiate a
 * driver adapter. The query and result types are specific to the adapter.
 */
declare interface DriverAdapterFactory<Query$1, Result$1> extends AdapterInfo {
  /**
   * Instantiate a driver adapter.
   */
  connect(): Promise<Queryable<Query$1, Result$1>>;
}
declare type DynamicArgType = ArgType | {
  arity: 'tuple';
  elements: ArgType[];
};

/** Client */
declare type DynamicClientExtensionArgs<C_, TypeMap extends TypeMapDef, TypeMapCb extends TypeMapCbDef, ExtArgs extends Record<string, any>> = { [P in keyof C_]: unknown } & {
  [K: symbol]: {
    ctx: Optional<DynamicClientExtensionThis<TypeMap, TypeMapCb, ExtArgs>, ITXClientDenyList> & {
      $parent: Optional<DynamicClientExtensionThis<TypeMap, TypeMapCb, ExtArgs>, ITXClientDenyList>;
    };
  };
};
declare type DynamicClientExtensionThis<TypeMap extends TypeMapDef, TypeMapCb extends TypeMapCbDef, ExtArgs extends Record<string, any>> = { [P in keyof ExtArgs['client']]: Return<ExtArgs['client'][P]> } & { [P in Exclude<TypeMap['meta']['modelProps'], keyof ExtArgs['client']>]: DynamicModelExtensionThis<TypeMap, ModelKey<TypeMap, P>, ExtArgs> } & { [P in Exclude<keyof TypeMap['other']['operations'], keyof ExtArgs['client']>]: P extends keyof ClientOtherOps ? ClientOtherOps[P] : never } & { [P in Exclude<ClientBuiltInProp, keyof ExtArgs['client']>]: DynamicClientExtensionThisBuiltin<TypeMap, TypeMapCb, ExtArgs>[P] } & {
  [K: symbol]: {
    types: TypeMap['other'];
  };
};
declare type DynamicClientExtensionThisBuiltin<TypeMap extends TypeMapDef, TypeMapCb extends TypeMapCbDef, ExtArgs extends Record<string, any>> = {
  $extends: ExtendsHook<'extends', TypeMapCb, ExtArgs, Call<TypeMapCb, {
    extArgs: ExtArgs;
  }>>;
  $transaction<P$1 extends PrismaPromise<any>[]>(arg: [...P$1], options?: {
    isolationLevel?: TypeMap['meta']['txIsolationLevel'];
  }): Promise<UnwrapTuple<P$1>>;
  $transaction<R$1>(fn: (client: Omit<DynamicClientExtensionThis<TypeMap, TypeMapCb, ExtArgs>, ITXClientDenyList>) => Promise<R$1>, options?: {
    maxWait?: number;
    timeout?: number;
    isolationLevel?: TypeMap['meta']['txIsolationLevel'];
  }): Promise<R$1>;
  $disconnect(): Promise<void>;
  $connect(): Promise<void>;
};
/** Model */
declare type DynamicModelExtensionArgs<M_, TypeMap extends TypeMapDef, TypeMapCb extends TypeMapCbDef, ExtArgs extends Record<string, any>> = { [K in keyof M_]: K extends '$allModels' ? { [P in keyof M_[K]]?: unknown } & {
  [K: symbol]: {};
} : K extends TypeMap['meta']['modelProps'] ? { [P in keyof M_[K]]?: unknown } & {
  [K: symbol]: {
    ctx: DynamicModelExtensionThis<TypeMap, ModelKey<TypeMap, K>, ExtArgs> & {
      $parent: DynamicClientExtensionThis<TypeMap, TypeMapCb, ExtArgs>;
    } & {
      $name: ModelKey<TypeMap, K>;
    } & {
      /**
       * @deprecated Use `$name` instead.
       */
      name: ModelKey<TypeMap, K>;
    };
  };
} : never };
declare type DynamicModelExtensionFluentApi<TypeMap extends TypeMapDef, M extends PropertyKey, P$1 extends PropertyKey, Null> = { [K in keyof TypeMap['model'][M]['payload']['objects']]: <A>(args?: Exact<A, Path<TypeMap['model'][M]['operations'][P$1]['args']['select'], [K]>>) => PrismaPromise<Path<DynamicModelExtensionFnResultBase<TypeMap, M, {
  select: { [P in K]: A };
}, P$1>, [K]> | Null> & DynamicModelExtensionFluentApi<TypeMap, (TypeMap['model'][M]['payload']['objects'][K] & {})['name'], P$1, Null | Select<TypeMap['model'][M]['payload']['objects'][K], null>> };
declare type DynamicModelExtensionFnResult<TypeMap extends TypeMapDef, M extends PropertyKey, A, P$1 extends PropertyKey, Null> = P$1 extends FluentOperation ? DynamicModelExtensionFluentApi<TypeMap, M, P$1, Null> & PrismaPromise<DynamicModelExtensionFnResultBase<TypeMap, M, A, P$1> | Null> : PrismaPromise<DynamicModelExtensionFnResultBase<TypeMap, M, A, P$1>>;
declare type DynamicModelExtensionFnResultBase<TypeMap extends TypeMapDef, M extends PropertyKey, A, P$1 extends PropertyKey> = GetResult<TypeMap['model'][M]['payload'], A, P$1 & Operation, TypeMap['globalOmitOptions']>;
declare type DynamicModelExtensionFnResultNull<P$1 extends PropertyKey> = P$1 extends 'findUnique' | 'findFirst' ? null : never;
declare type DynamicModelExtensionOperationFn<TypeMap extends TypeMapDef, M extends PropertyKey, P$1 extends PropertyKey> = {} extends TypeMap['model'][M]['operations'][P$1]['args'] ? <A extends TypeMap['model'][M]['operations'][P$1]['args']>(args?: Exact<A, TypeMap['model'][M]['operations'][P$1]['args']>) => DynamicModelExtensionFnResult<TypeMap, M, A, P$1, DynamicModelExtensionFnResultNull<P$1>> : <A extends TypeMap['model'][M]['operations'][P$1]['args']>(args: Exact<A, TypeMap['model'][M]['operations'][P$1]['args']>) => DynamicModelExtensionFnResult<TypeMap, M, A, P$1, DynamicModelExtensionFnResultNull<P$1>>;
declare type DynamicModelExtensionThis<TypeMap extends TypeMapDef, M extends PropertyKey, ExtArgs extends Record<string, any>> = { [P in keyof ExtArgs['model'][Uncapitalize<M & string>]]: Return<ExtArgs['model'][Uncapitalize<M & string>][P]> } & { [P in Exclude<keyof TypeMap['model'][M]['operations'], keyof ExtArgs['model'][Uncapitalize<M & string>]>]: DynamicModelExtensionOperationFn<TypeMap, M, P> } & { [P in Exclude<'fields', keyof ExtArgs['model'][Uncapitalize<M & string>]>]: TypeMap['model'][M]['fields'] } & {
  [K: symbol]: {
    types: TypeMap['model'][M];
  };
};
/** Query */
declare type DynamicQueryExtensionArgs<Q_, TypeMap extends TypeMapDef> = { [K in keyof Q_]: K extends '$allOperations' ? (args: {
  model?: string;
  operation: string;
  args: any;
  query: (args: any) => PrismaPromise<any>;
}) => Promise<any> : K extends '$allModels' ? { [P in keyof Q_[K] | keyof TypeMap['model'][keyof TypeMap['model']]['operations'] | '$allOperations']?: P extends '$allOperations' ? DynamicQueryExtensionCb<TypeMap, 'model', keyof TypeMap['model'], keyof TypeMap['model'][keyof TypeMap['model']]['operations']> : P extends keyof TypeMap['model'][keyof TypeMap['model']]['operations'] ? DynamicQueryExtensionCb<TypeMap, 'model', keyof TypeMap['model'], P> : never } : K extends TypeMap['meta']['modelProps'] ? { [P in keyof Q_[K] | keyof TypeMap['model'][ModelKey<TypeMap, K>]['operations'] | '$allOperations']?: P extends '$allOperations' ? DynamicQueryExtensionCb<TypeMap, 'model', ModelKey<TypeMap, K>, keyof TypeMap['model'][ModelKey<TypeMap, K>]['operations']> : P extends keyof TypeMap['model'][ModelKey<TypeMap, K>]['operations'] ? DynamicQueryExtensionCb<TypeMap, 'model', ModelKey<TypeMap, K>, P> : never } : K extends keyof TypeMap['other']['operations'] ? DynamicQueryExtensionCb<[TypeMap], 0, 'other', K> : never };
declare type DynamicQueryExtensionCb<TypeMap extends TypeMapDef, _0 extends PropertyKey, _1 extends PropertyKey, _2 extends PropertyKey> = <A extends DynamicQueryExtensionCbArgs<TypeMap, _0, _1, _2>>(args: A) => Promise<TypeMap[_0][_1][_2]['result']>;
declare type DynamicQueryExtensionCbArgs<TypeMap extends TypeMapDef, _0 extends PropertyKey, _1 extends PropertyKey, _2 extends PropertyKey> = (_1 extends unknown ? _2 extends unknown ? {
  args: DynamicQueryExtensionCbArgsArgs<TypeMap, _0, _1, _2>;
  model: _0 extends 0 ? undefined : _1;
  operation: _2;
  query: <A extends DynamicQueryExtensionCbArgsArgs<TypeMap, _0, _1, _2>>(args: A) => PrismaPromise<TypeMap[_0][_1]['operations'][_2]['result']>;
} : never : never) & {
  query: (args: DynamicQueryExtensionCbArgsArgs<TypeMap, _0, _1, _2>) => PrismaPromise<TypeMap[_0][_1]['operations'][_2]['result']>;
};
declare type DynamicQueryExtensionCbArgsArgs<TypeMap extends TypeMapDef, _0 extends PropertyKey, _1 extends PropertyKey, _2 extends PropertyKey> = _2 extends '$queryRaw' | '$executeRaw' ? Sql : TypeMap[_0][_1]['operations'][_2]['args'];
/** Result */
declare type DynamicResultExtensionArgs<R_, TypeMap extends TypeMapDef> = { [K in keyof R_]: { [P in keyof R_[K]]?: {
  needs?: DynamicResultExtensionNeeds<TypeMap, ModelKey<TypeMap, K>, R_[K][P]>;
  compute(data: DynamicResultExtensionData<TypeMap, ModelKey<TypeMap, K>, R_[K][P]>): any;
} } };
declare type DynamicResultExtensionData<TypeMap extends TypeMapDef, M extends PropertyKey, S$1> = GetFindResult<TypeMap['model'][M]['payload'], {
  select: S$1;
}, {}>;
declare type DynamicResultExtensionNeeds<TypeMap extends TypeMapDef, M extends PropertyKey, S$1> = { [K in keyof S$1]: K extends keyof TypeMap['model'][M]['payload']['scalars'] ? S$1[K] : never } & { [N in keyof TypeMap['model'][M]['payload']['scalars']]?: boolean };
declare type EmptyToUnknown<T$1> = T$1;
declare interface Engine<InteractiveTransactionPayload = unknown> {
  /** The name of the engine. This is meant to be consumed externally */
  readonly name: string;
  onBeforeExit(callback: () => Promise<void>): void;
  start(): Promise<void>;
  stop(): Promise<void>;
  version(forceRun?: boolean): Promise<string> | string;
  request<T$1>(query: JsonQuery, options: RequestOptions<InteractiveTransactionPayload>): Promise<QueryEngineResultData<T$1>>;
  requestBatch<T$1>(queries: JsonQuery[], options: RequestBatchOptions<InteractiveTransactionPayload>): Promise<BatchQueryEngineResult<T$1>[]>;
  transaction(action: 'start', headers: Transaction_2.TransactionHeaders, options: Transaction_2.Options): Promise<Transaction_2.InteractiveTransactionInfo<unknown>>;
  transaction(action: 'commit', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
  transaction(action: 'rollback', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
}
declare interface EngineConfig {
  enableDebugLogs?: boolean;
  prismaPath?: string;
  logQueries?: boolean;
  logLevel?: 'info' | 'warn';
  clientVersion: string;
  previewFeatures?: string[];
  activeProvider?: string;
  logEmitter: LogEmitter;
  transactionOptions: Transaction_2.Options;
  /**
   * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
   */
  adapter?: SqlDriverAdapterFactory;
  /**
   * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
   */
  accelerateUrl?: string;
  /**
   * The contents of the schema encoded into a string
   */
  inlineSchema: string;
  /**
   * The helper for interaction with OTEL tracing
   * @remarks enabling is determined by the client and @prisma/instrumentation package
   */
  tracingHelper: TracingHelper;
  /**
   * Web Assembly module loading configuration
   */
  compilerWasm?: CompilerWasmLoadingConfig;
  /**
   * SQL commenter plugins that add metadata to SQL queries as comments.
   * Each plugin receives query context and returns key-value pairs.
   */
  sqlCommenters?: SqlCommenterPlugin[];
  /**
   * Parameterization schema (ParamGraph) for schema-aware query parameterization.
   * Enables precise parameterization based on DMMF metadata.
   */
  parameterizationSchema: SerializedParamGraph;
  /**
   * Runtime data model for enum lookups during parameterization.
   */
  runtimeDataModel: RuntimeDataModel;
}
declare type EngineEvent<E$1 extends EngineEventType> = E$1 extends QueryEventType ? QueryEvent : LogEvent;
declare type EngineEventType = QueryEventType | LogEventType;
declare type EngineSpan = {
  id: EngineSpanId;
  parentId: string | null;
  name: string;
  startTime: HrTime;
  endTime: HrTime;
  kind: EngineSpanKind;
  attributes?: Record<string, unknown>;
  links?: EngineSpanId[];
};
declare type EngineSpanId = string;
declare type EngineSpanKind = 'client' | 'internal';
declare type EnumValue = ReadonlyDeep_2<{
  name: string;
  dbName: string | null;
}>;
declare type Equals<A, B> = (<T$1>() => T$1 extends A ? 1 : 2) extends (<T$1>() => T$1 extends B ? 1 : 2) ? 1 : 0;
declare type ErrorFormat$1 = 'pretty' | 'colorless' | 'minimal';
declare type EventCallback<E$1 extends ExtendedEventType> = [E$1] extends ['beforeExit'] ? () => Promise<void> : [E$1] extends [LogLevel$1] ? (event: EngineEvent<E$1>) => void : never;
declare type Exact<A, W> = (A extends unknown ? (W extends A ? { [K in keyof A]: Exact<A[K], W[K]> } : W) : never) | (A extends Narrowable ? A : never);
/**
 * Defines Exception.
 *
 * string or an object with one of (message or name or code) and optional stack
 */
declare type Exception = ExceptionWithCode | ExceptionWithMessage | ExceptionWithName | string;
declare interface ExceptionWithCode {
  code: string | number;
  name?: string;
  message?: string;
  stack?: string;
}
declare interface ExceptionWithMessage {
  code?: string | number;
  message: string;
  name?: string;
  stack?: string;
}
declare interface ExceptionWithName {
  code?: string | number;
  message?: string;
  name: string;
  stack?: string;
}
declare type ExtendedEventType = LogLevel$1 | 'beforeExit';
declare interface ExtendedSpanOptions extends SpanOptions {
  /** The name of the span */
  name: string;
  internal?: boolean;
  /** Whether it propagates context (?=true) */
  active?: boolean;
  /** The context to append the span to */
  context?: Context;
}

/** $extends, defineExtension */
declare interface ExtendsHook<Variant extends 'extends' | 'define', TypeMapCb extends TypeMapCbDef, ExtArgs extends Record<string, any>, TypeMap extends TypeMapDef = Call<TypeMapCb, {
  extArgs: ExtArgs;
}>> {
  extArgs: ExtArgs;
  <R_ extends { [K in TypeMap['meta']['modelProps'] | '$allModels']?: unknown }, R$1, M_ extends { [K in TypeMap['meta']['modelProps'] | '$allModels']?: unknown }, M, Q_ extends { [K in TypeMap['meta']['modelProps'] | '$allModels' | keyof TypeMap['other']['operations'] | '$allOperations']?: unknown }, C_ extends { [K in string]?: unknown }, C$1, Args$1 extends InternalArgs = InternalArgs<R$1, M, {}, C$1>, MergedArgs extends InternalArgs = MergeExtArgs<TypeMap, ExtArgs, Args$1>>(extension: ((client: DynamicClientExtensionThis<TypeMap, TypeMapCb, ExtArgs>) => {
    $extends: {
      extArgs: Args$1;
    };
  }) | {
    name?: string;
    query?: DynamicQueryExtensionArgs<Q_, TypeMap>;
    result?: DynamicResultExtensionArgs<R_, TypeMap> & R$1;
    model?: DynamicModelExtensionArgs<M_, TypeMap, TypeMapCb, ExtArgs> & M;
    client?: DynamicClientExtensionArgs<C_, TypeMap, TypeMapCb, ExtArgs> & C$1;
  }): {
    extends: DynamicClientExtensionThis<Call<TypeMapCb, {
      extArgs: MergedArgs;
    }>, TypeMapCb, MergedArgs>;
    define: (client: any) => {
      $extends: {
        extArgs: Args$1;
      };
    };
  }[Variant];
}
declare type ExtensionArgs = Optional<RequiredExtensionArgs>;
declare namespace Extensions {
  export { defineExtension, getExtensionContext };
}
declare namespace Extensions_2 {
  export { InternalArgs, DefaultArgs, GetPayloadResultExtensionKeys, GetPayloadResultExtensionObject, GetPayloadResult, GetSelect, GetOmit, DynamicQueryExtensionArgs, DynamicQueryExtensionCb, DynamicQueryExtensionCbArgs, DynamicQueryExtensionCbArgsArgs, DynamicResultExtensionArgs, DynamicResultExtensionNeeds, DynamicResultExtensionData, DynamicModelExtensionArgs, DynamicModelExtensionThis, DynamicModelExtensionOperationFn, DynamicModelExtensionFnResult, DynamicModelExtensionFnResultBase, DynamicModelExtensionFluentApi, DynamicModelExtensionFnResultNull, DynamicClientExtensionArgs, DynamicClientExtensionThis, ClientBuiltInProp, DynamicClientExtensionThisBuiltin, ExtendsHook, MergeExtArgs, AllModelsToStringIndex, TypeMapDef, DevTypeMapDef, DevTypeMapFnDef, ClientOptionDef, ClientOtherOps, TypeMapCbDef, ModelKey, RequiredExtensionArgs as UserArgs };
}
declare type ExtractGlobalOmit<Options$1, ModelName$1 extends string> = Options$1 extends {
  omit: { [K in ModelName$1]: infer GlobalOmit };
} ? GlobalOmit : {};
declare type Field = ReadonlyDeep_2<{
  kind: FieldKind;
  name: string;
  isRequired: boolean;
  isList: boolean;
  isUnique: boolean;
  isId: boolean;
  isReadOnly: boolean;
  isGenerated?: boolean;
  isUpdatedAt?: boolean;
  /**
   * Describes the data type in the same the way it is defined in the Prisma schema:
   * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName
   */
  type: string;
  /**
   * Native database type, if specified.
   * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`,
   * `@db.Text` is encoded as `['Text', []]`.
   */
  nativeType?: [string, string[]] | null;
  dbName?: string | null;
  hasDefaultValue: boolean;
  default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[];
  relationFromFields?: string[];
  relationToFields?: string[];
  relationOnDelete?: string;
  relationOnUpdate?: string;
  relationName?: string;
  documentation?: string;
}>;
declare type FieldDefault = ReadonlyDeep_2<{
  name: string;
  args: Array<string | number>;
}>;
declare type FieldDefaultScalar = string | boolean | number;
declare type FieldInitializer = {
  type: 'value';
  value: PrismaValue;
} | {
  type: 'lastInsertId';
};
declare type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported';
declare type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes';
declare type FieldNamespace = 'model' | 'prisma';
declare type FieldOperation = {
  type: 'set';
  value: PrismaValue;
} | {
  type: 'add';
  value: PrismaValue;
} | {
  type: 'subtract';
  value: PrismaValue;
} | {
  type: 'multiply';
  value: PrismaValue;
} | {
  type: 'divide';
  value: PrismaValue;
};

/**
 * A reference to a specific field of a specific model
 */
declare interface FieldRef$1<Model$1, FieldType$1> {
  readonly modelName: Model$1;
  readonly name: string;
  readonly typeName: FieldType$1;
  readonly isList: boolean;
}
declare type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
declare type FieldRefType = ReadonlyDeep_2<{
  name: string;
  allowTypes: FieldRefAllowType[];
  fields: SchemaArg[];
}>;
declare type FieldScalarType = {
  type: 'string' | 'int' | 'bigint' | 'float' | 'boolean' | 'json' | 'object' | 'datetime' | 'decimal' | 'unsupported';
} | {
  type: 'enum';
  name: string;
} | {
  type: 'bytes';
  encoding: 'array' | 'base64' | 'hex';
};
declare type FieldType = {
  arity: Arity;
} & FieldScalarType;
declare type FluentOperation = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'update' | 'upsert' | 'delete';
declare interface Fn<Params = unknown, Returns = unknown> {
  params: Params;
  returns: Returns;
}
declare type Fragment = {
  type: 'stringChunk';
  chunk: string;
} | {
  type: 'parameter';
} | {
  type: 'parameterTuple';
  itemPrefix: string;
  itemSeparator: string;
  itemSuffix: string;
} | {
  type: 'parameterTupleList';
  itemPrefix: string;
  itemSeparator: string;
  itemSuffix: string;
  groupSeparator: string;
};
declare type GetAggregateResult<P$1 extends OperationPayload, A> = { [K in keyof A as K extends Aggregate ? K : never]: K extends '_count' ? A[K] extends true ? number : Count<A[K]> : { [J in keyof A[K] & string]: P$1['scalars'][J] | null } };
declare type GetBatchResult = {
  count: number;
};
declare type GetCountResult<A> = A extends {
  select: infer S;
} ? (S extends true ? number : Count<S>) : number;
declare function getExtensionContext<T$1>(that: T$1): Context_2<T$1>;
declare type GetFindResult<P$1 extends OperationPayload, A, GlobalOmitOptions$1> = Equals<A, any> extends 1 ? DefaultSelection<P$1, A, GlobalOmitOptions$1> : A extends {
  select: infer S extends object;
} & Record<string, unknown> | {
  include: infer I extends object;
} & Record<string, unknown> ? { [K in keyof S | keyof I as (S & I)[K] extends false | undefined | Skip | null ? never : K]: (S & I)[K] extends object ? P$1 extends SelectablePayloadFields<K, (infer O)[]> ? O extends OperationPayload ? GetFindResult<O, (S & I)[K], GlobalOmitOptions$1>[] : never : P$1 extends SelectablePayloadFields<K, infer O | null> ? O extends OperationPayload ? GetFindResult<O, (S & I)[K], GlobalOmitOptions$1> | SelectField<P$1, K> & null : never : K extends '_count' ? Count<GetFindResult<P$1, (S & I)[K], GlobalOmitOptions$1>> : never : P$1 extends SelectablePayloadFields<K, (infer O)[]> ? O extends OperationPayload ? DefaultSelection<O, {}, GlobalOmitOptions$1>[] : never : P$1 extends SelectablePayloadFields<K, infer O | null> ? O extends OperationPayload ? DefaultSelection<O, {}, GlobalOmitOptions$1> | SelectField<P$1, K> & null : never : P$1 extends {
  scalars: { [k in K]: infer O };
} ? O : K extends '_count' ? Count<P$1['objects']> : never } & (A extends {
  include: any;
} & Record<string, unknown> ? DefaultSelection<P$1, A & {
  omit: A['omit'];
}, GlobalOmitOptions$1> : unknown) : DefaultSelection<P$1, A, GlobalOmitOptions$1>;
declare type GetGroupByResult<P$1 extends OperationPayload, A> = A extends {
  by: string[];
} ? Array<GetAggregateResult<P$1, A> & { [K in A['by'][number]]: P$1['scalars'][K] }> : A extends {
  by: string;
} ? Array<GetAggregateResult<P$1, A> & { [K in A['by']]: P$1['scalars'][K] }> : {}[];
declare type GetOmit<BaseKeys extends string, R$1 extends InternalArgs['result'][string], ExtraType = never> = { [K in (string extends keyof R$1 ? never : keyof R$1) | BaseKeys]?: boolean | ExtraType };
declare type GetPayloadResult<Base extends Record<any, any>, R$1 extends InternalArgs['result'][string]> = Omit<Base, GetPayloadResultExtensionKeys<R$1>> & GetPayloadResultExtensionObject<R$1>;
declare type GetPayloadResultExtensionKeys<R$1 extends InternalArgs['result'][string], KR extends keyof R$1 = (string extends keyof R$1 ? never : keyof R$1)> = KR;
declare type GetPayloadResultExtensionObject<R$1 extends InternalArgs['result'][string]> = { [K in GetPayloadResultExtensionKeys<R$1>]: R$1[K] extends (() => {
  compute: (...args: any) => infer C;
}) ? C : never };
declare function getPrismaClient(config: GetPrismaClientConfig): {
  new (optionsArg: PrismaClientOptions): {
    _originalClient: any;
    _runtimeDataModel: RuntimeDataModel;
    _requestHandler: RequestHandler;
    _connectionPromise?: Promise<any> | undefined;
    _disconnectionPromise?: Promise<any> | undefined;
    _engineConfig: EngineConfig;
    _accelerateEngineConfig: AccelerateEngineConfig;
    _clientVersion: string;
    _errorFormat: ErrorFormat$1;
    _tracingHelper: TracingHelper;
    _previewFeatures: string[];
    _activeProvider: string;
    _globalOmit?: GlobalOmitOptions | undefined;
    _extensions: MergedExtensionsList;
    /**
     * @remarks This is used internally by Policy, do not rename or remove
     */
    _engine: Engine;
    /**
     * A fully constructed/applied Client that references the parent
     * PrismaClient. This is used for Client extensions only.
     */
    _appliedParent: any;
    _createPrismaPromise: PrismaPromiseFactory;
    $on<E$1 extends ExtendedEventType>(eventType: E$1, callback: EventCallback<E$1>): any;
    $connect(): Promise<void>;
    /**
     * Disconnect from the database
     */
    $disconnect(): Promise<void>;
    /**
     * Executes a raw query and always returns a number
     */
    $executeRawInternal(transaction: PrismaPromiseTransaction | undefined, clientMethod: string, args: RawQueryArgs, middlewareArgsMapper?: MiddlewareArgsMapper<unknown, unknown>): Promise<number>;
    /**
     * Executes a raw query provided through a safe tag function
     * @see https://github.com/prisma/prisma/issues/7142
     *
     * @param query
     * @param values
     * @returns
     */
    $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2<unknown, any>;
    /**
     * Unsafe counterpart of `$executeRaw` that is susceptible to SQL injections
     * @see https://github.com/prisma/prisma/issues/7142
     *
     * @param query
     * @param values
     * @returns
     */
    $executeRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2<unknown, any>;
    /**
     * Executes a raw command only for MongoDB
     *
     * @param command
     * @returns
     */
    $runCommandRaw(command: Record<string, JsInputValue>): PrismaPromise_2<unknown, any>;
    /**
     * Executes a raw query and returns selected data
     */
    $queryRawInternal(transaction: PrismaPromiseTransaction | undefined, clientMethod: string, args: RawQueryArgs, middlewareArgsMapper?: MiddlewareArgsMapper<unknown, unknown>): Promise<any>;
    /**
     * Executes a raw query provided through a safe tag function
     * @see https://github.com/prisma/prisma/issues/7142
     *
     * @param query
     * @param values
     * @returns
     */
    $queryRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2<unknown, any>;
    /**
     * Counterpart to $queryRaw, that returns strongly typed results
     * @param typedSql
     */
    $queryRawTyped(typedSql: UnknownTypedSql): PrismaPromise_2<unknown, any>;
    /**
     * Unsafe counterpart of `$queryRaw` that is susceptible to SQL injections
     * @see https://github.com/prisma/prisma/issues/7142
     *
     * @param query
     * @param values
     * @returns
     */
    $queryRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2<unknown, any>;
    /**
     * Execute a batch of requests in a transaction
     * @param requests
     * @param options
     */
    _transactionWithArray({
      promises,
      options
    }: {
      promises: Array<PrismaPromise_2<any>>;
      options?: BatchTransactionOptions;
    }): Promise<any>;
    /**
     * Perform a long-running transaction
     * @param callback
     * @param options
     * @returns
     */
    _transactionWithCallback({
      callback,
      options
    }: {
      callback: (client: Client) => Promise<unknown>;
      options?: Options;
    }): Promise<unknown>;
    _createItxClient(transaction: PrismaPromiseInteractiveTransaction, scopeId: string, scopeState: ItxScopeState): Client;
    /**
     * Execute queries within a transaction
     * @param input a callback or a query list
     * @param options to set timeouts (callback)
     * @returns
     */
    $transaction(input: any, options?: any): Promise<any>;
    /**
     * Runs the middlewares over params before executing a request
     * @param internalParams
     * @returns
     */
    _request(internalParams: InternalRequestParams): Promise<any>;
    _executeRequest({
      args,
      clientMethod,
      dataPath,
      callsite,
      action,
      model,
      argsMapper,
      transaction,
      unpacker,
      otelParentCtx,
      customDataProxyFetch
    }: InternalRequestParams): Promise<any>;
    /**
     * Shortcut for checking a preview flag
     * @param feature preview flag
     * @returns
     */
    _hasPreviewFlag(feature: string): boolean;
    $extends: typeof $extends;
    readonly [Symbol.toStringTag]: string;
  };
};
/**
 * Config that is stored into the generated client. When the generated client is
 * loaded, this same config is passed to {@link getPrismaClient} which creates a
 * closure with that config around a non-instantiated [[PrismaClient]].
 */
declare type GetPrismaClientConfig = {
  runtimeDataModel: RuntimeDataModel;
  previewFeatures: string[];
  clientVersion: string;
  engineVersion: string;
  activeProvider: ActiveConnectorType;
  /**
   * The contents of the schema encoded into a string
   */
  inlineSchema: string;
  /**
   * Optional wasm loading configuration
   */
  compilerWasm?: CompilerWasmLoadingConfig;
  /**
   * Parameterization schema for schema-aware query parameterization.
   * Enables precise parameterization based on DMMF metadata.
   */
  parameterizationSchema: SerializedParamGraph;
};
declare type GetResult<Payload$1 extends OperationPayload, Args$1, OperationName extends Operation = 'findUniqueOrThrow', GlobalOmitOptions$1 = {}> = {
  findUnique: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1> | null;
  findUniqueOrThrow: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>;
  findFirst: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1> | null;
  findFirstOrThrow: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>;
  findMany: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>[];
  create: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>;
  createMany: GetBatchResult;
  createManyAndReturn: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>[];
  update: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>;
  updateMany: GetBatchResult;
  updateManyAndReturn: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>[];
  upsert: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>;
  delete: GetFindResult<Payload$1, Args$1, GlobalOmitOptions$1>;
  deleteMany: GetBatchResult;
  aggregate: GetAggregateResult<Payload$1, Args$1>;
  count: GetCountResult<Args$1>;
  groupBy: GetGroupByResult<Payload$1, Args$1>;
  $queryRaw: unknown;
  $queryRawTyped: unknown;
  $executeRaw: number;
  $queryRawUnsafe: unknown;
  $executeRawUnsafe: number;
  $runCommandRaw: JsonObject;
  findRaw: JsonObject;
  aggregateRaw: JsonObject;
}[OperationName];
declare function getRuntime(): GetRuntimeOutput;
declare type GetRuntimeOutput = {
  id: RuntimeName;
  prettyName: string;
  isEdge: boolean;
};
declare type GetSelect<Base extends Record<any, any>, R$1 extends InternalArgs['result'][string], KR extends keyof R$1 = (string extends keyof R$1 ? never : keyof R$1)> = { [K in KR | keyof Base]?: K extends KR ? boolean : Base[K] };
declare type GlobalOmitOptions = {
  [modelName: string]: {
    [fieldName: string]: boolean;
  };
};
declare type HandleErrorParams = {
  args: JsArgs;
  error: any;
  clientMethod: string;
  callsite?: CallSite;
  transaction?: PrismaPromiseTransaction;
  modelName?: string;
  globalOmit?: GlobalOmitOptions;
};
declare type HrTime = [number, number];

/**
 * Defines High-Resolution Time.
 *
 * The first number, HrTime[0], is UNIX Epoch time in seconds since 00:00:00 UTC on 1 January 1970.
 * The second number, HrTime[1], represents the partial second elapsed since Unix Epoch time represented by first number in nanoseconds.
 * For example, 2021-01-01T12:30:10.150Z in UNIX Epoch time in milliseconds is represented as 1609504210150.
 * The first number is calculated by converting and truncating the Epoch time in milliseconds to seconds:
 * HrTime[0] = Math.trunc(1609504210150 / 1000) = 1609504210.
 * The second number is calculated by converting the digits after the decimal point of the subtraction, (1609504210150 / 1000) - HrTime[0], to nanoseconds:
 * HrTime[1] = Number((1609504210.150 - HrTime[0]).toFixed(9)) * 1e9 = 150000000.
 * This is represented in HrTime format as [1609504210, 150000000].
 */
declare type HrTime_2 = [number, number];
declare type Index = ReadonlyDeep_2<{
  model: string;
  type: IndexType;
  isDefinedOnField: boolean;
  name?: string;
  dbName?: string;
  algorithm?: string;
  clustered?: boolean;
  fields: IndexField[];
}>;
declare type IndexField = ReadonlyDeep_2<{
  name: string;
  sortOrder?: SortOrder$1;
  length?: number;
  operatorClass?: string;
}>;
declare type IndexType = 'id' | 'normal' | 'unique' | 'fulltext';
declare type InMemoryOps = {
  pagination: Pagination | null;
  distinct: string[] | null;
  reverse: boolean;
  linkingFields: string[] | null;
  nested: Record<string, InMemoryOps>;
};

/**
 * Matches a JSON array.
 * Unlike \`JsonArray\`, readonly arrays are assignable to this type.
 */
declare interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {}
/**
 * Matches a JSON object.
 * Unlike \`JsonObject\`, this type allows undefined and read-only properties.
 */
declare type InputJsonObject = { readonly [Key in string]?: InputJsonValue | null };
/**
 * Matches any valid value that can be used as an input for operations like
 * create and update as the value of a JSON field. Unlike \`JsonValue\`, this
 * type allows read-only arrays and read-only object properties and disallows
 * \`null\` at the top level.
 *
 * \`null\` cannot be used as the value of a JSON field because its meaning
 * would be ambiguous. Use \`Prisma.JsonNull\` to store the JSON null value or
 * \`Prisma.DbNull\` to clear the JSON value and set the field to the database
 * NULL value instead.
 *
 * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
 */
declare type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | {
  toJSON(): unknown;
};
declare type InputType = ReadonlyDeep_2<{
  name: string;
  constraints: {
    maxNumFields: number | null;
    minNumFields: number | null;
    fields?: string[];
  };
  meta?: {
    source?: string;
    grouping?: string;
  };
  fields: SchemaArg[];
}>;
declare type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
declare type InteractiveTransactionInfo<Payload$1 = unknown> = {
  /**
   * Transaction ID returned by the query engine.
   */
  id: string;
  /**
   * Arbitrary payload the meaning of which depends on the `Engine` implementation.
   * It is currently not used in `LibraryEngine`.
   */
  payload: Payload$1;
};
declare type InteractiveTransactionOptions<Payload$1> = Transaction_2.InteractiveTransactionInfo<Payload$1>;
declare type InternalArgs<R$1 = { [K in string]: { [K in string]: unknown } }, M = { [K in string]: { [K in string]: unknown } }, Q = { [K in string]: { [K in string]: unknown } }, C$1 = { [K in string]: unknown }> = {
  result: { [K in keyof R$1]: { [P in keyof R$1[K]]: () => R$1[K][P] } };
  model: { [K in keyof M]: { [P in keyof M[K]]: () => M[K][P] } };
  query: { [K in keyof Q]: { [P in keyof Q[K]]: () => Q[K][P] } };
  client: { [K in keyof C$1]: () => C$1[K] };
};
declare type InternalRequestParams = {
  /**
   * The original client method being called.
   * Even though the rootField / operation can be changed,
   * this method stays as it is, as it's what the user's
   * code looks like
   */
  clientMethod: string;
  /**
   * Name of js model that triggered the request. Might be used
   * for warnings or error messages
   */
  jsModelName?: string;
  callsite?: CallSite;
  transaction?: PrismaPromiseTransaction;
  unpacker?: Unpacker;
  otelParentCtx?: Context;
  /** Used to "desugar" a user input into an "expanded" one */
  argsMapper?: (args?: UserArgs_2) => UserArgs_2;
  /** Used to convert args for middleware and back */
  middlewareArgsMapper?: MiddlewareArgsMapper<unknown, unknown>;
  /** Used for Accelerate client extension via Data Proxy */
  customDataProxyFetch?: AccelerateExtensionFetchDecorator;
} & Omit<QueryMiddlewareParams, 'runInTransaction'>;
declare type IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SNAPSHOT' | 'SERIALIZABLE';
declare type IsolationLevel_2 = 'ReadUncommitted' | 'ReadCommitted' | 'RepeatableRead' | 'Snapshot' | 'Serializable';
declare function isSkip(value: unknown): value is Skip;
declare function isTypedSql(value: unknown): value is UnknownTypedSql;
declare type ITXClientDenyList = (typeof denylist)[number];
declare const itxClientDenyList: readonly (string | symbol)[];
declare type ItxScopeState = {
  stack: string[];
};
declare interface Job {
  resolve: (data: any) => void;
  reject: (data: any) => void;
  request: any;
}
declare type JoinExpression = {
  child: QueryPlanNode;
  on: [left: string, right: string][];
  parentField: string;
  isRelationUnique: boolean;
};
declare type JsArgs = {
  select?: Selection_2;
  include?: Selection_2;
  omit?: Omission;
  [argName: string]: JsInputValue;
};
declare type JsInputValue = null | undefined | string | number | boolean | bigint | Uint8Array | Date | DecimalJsLike | ObjectEnumValue | RawParameters | JsonConvertible | FieldRef$1<string, unknown> | JsInputValue[] | Skip | {
  [key: string]: JsInputValue;
};
declare type JsonArgumentValue = number | string | boolean | null | RawTaggedValue | JsonArgumentValue[] | {
  [key: string]: JsonArgumentValue;
};

/**
 * From https://github.com/sindresorhus/type-fest/
 * Matches a JSON array.
 */
declare interface JsonArray extends Array<JsonValue> {}
declare type JsonBatchQuery = {
  batch: JsonQuery[];
  transaction?: {
    isolationLevel?: IsolationLevel_2;
  };
};
declare interface JsonConvertible {
  toJSON(): unknown;
}
declare type JsonFieldSelection = {
  arguments?: Record<string, JsonArgumentValue> | RawTaggedValue;
  selection: JsonSelectionSet;
};
/**
 * From https://github.com/sindresorhus/type-fest/
 * Matches a JSON object.
 * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from.
 */
declare type JsonObject = { [Key in string]?: JsonValue };
declare type JsonQuery = {
  modelName?: string;
  action: JsonQueryAction_2;
  query: JsonFieldSelection;
};
declare type JsonQueryAction = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'createOne' | 'createMany' | 'createManyAndReturn' | 'updateOne' | 'updateMany' | 'updateManyAndReturn' | 'deleteOne' | 'deleteMany' | 'upsertOne' | 'aggregate' | 'groupBy' | 'executeRaw' | 'queryRaw' | 'runCommandRaw' | 'findRaw' | 'aggregateRaw';
declare type JsonQueryAction_2 = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'createOne' | 'createMany' | 'createManyAndReturn' | 'updateOne' | 'updateMany' | 'updateManyAndReturn' | 'deleteOne' | 'deleteMany' | 'upsertOne' | 'aggregate' | 'groupBy' | 'executeRaw' | 'queryRaw' | 'runCommandRaw' | 'findRaw' | 'aggregateRaw';
declare type JsonSelectionSet = {
  $scalars?: boolean;
  $composites?: boolean;
} & {
  [fieldName: string]: boolean | JsonFieldSelection;
};

/**
 * From https://github.com/sindresorhus/type-fest/
 * Matches any valid JSON value.
 */
declare type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
declare type JsOutputValue = null | string | number | boolean | bigint | Uint8Array | Date | Decimal | JsOutputValue[] | {
  [key: string]: JsOutputValue;
};
declare type JsPromise<T$1> = Promise<T$1> & {};
/**
 * A pointer from the current {@link Span} to another span in the same trace or
 * in a different trace.
 * Few examples of Link usage.
 * 1. Batch Processing: A batch of elements may contain elements associated
 *    with one or more traces/spans. Since there can only be one parent
 *    SpanContext, Link is used to keep reference to SpanContext of all
 *    elements in the batch.
 * 2. Public Endpoint: A SpanContext in incoming client request on a public
 *    endpoint is untrusted from service provider perspective. In such case it
 *    is advisable to start a new trace with appropriate sampling decision.
 *    However, it is desirable to associate incoming SpanContext to new trace
 *    initiated on service provider side so two traces (from Client and from
 *    Service Provider) can be correlated.
 */
declare interface Link {
  /** The {@link SpanContext} of a linked span. */
  context: SpanContext;
  /** A set of {@link SpanAttributes} on the link. */
  attributes?: SpanAttributes;
  /** Count of attributes of the link that were dropped due to collection limits */
  droppedAttributesCount?: number;
}
declare type LocationInFile = {
  fileName: string;
  lineNumber: number | null;
  columnNumber: number | null;
};
declare type LogDefinition$1 = {
  level: LogLevel$1;
  emit: 'stdout' | 'event';
};

/**
 * Typings for the events we emit.
 *
 * @remarks
 * If this is updated, our edge runtime shim needs to be updated as well.
 */
declare type LogEmitter = {
  on<E$1 extends EngineEventType>(event: E$1, listener: (event: EngineEvent<E$1>) => void): LogEmitter;
  emit(event: QueryEventType, payload: QueryEvent): boolean;
  emit(event: LogEventType, payload: LogEvent): boolean;
};
declare type LogEvent = {
  timestamp: Date;
  message: string;
  target: string;
};
declare type LogEventType = 'info' | 'warn' | 'error';
declare type LogLevel$1 = 'info' | 'query' | 'warn' | 'error';

/**
 * Generates more strict variant of an enum which, unlike regular enum,
 * throws on non-existing property access. This can be useful in following situations:
 * - we have an API, that accepts both `undefined` and `SomeEnumType` as an input
 * - enum values are generated dynamically from DMMF.
 *
 * In that case, if using normal enums and no compile-time typechecking, using non-existing property
 * will result in `undefined` value being used, which will be accepted. Using strict enum
 * in this case will help to have a runtime exception, telling you that you are probably doing something wrong.
 *
 * Note: if you need to check for existence of a value in the enum you can still use either
 * `in` operator or `hasOwnProperty` function.
 *
 * @param definition
 * @returns
 */
declare function makeStrictEnum<T$1 extends Record<PropertyKey, string | number>>(definition: T$1): T$1;
declare function makeTypedQueryFactory(sql: string): (...values: any[]) => TypedSql<any[], unknown>;
declare type Mappings = ReadonlyDeep_2<{
  modelOperations: ModelMapping[];
  otherOperations: {
    read: string[];
    write: string[];
  };
}>;

/**
 * Class that holds the list of all extensions, applied to particular instance,
 * as well as resolved versions of the components that need to apply on
 * different levels. Main idea of this class: avoid re-resolving as much of the
 * stuff as possible when new extensions are added while also delaying the
 * resolve until the point it is actually needed. For example, computed fields
 * of the model won't be resolved unless the model is actually queried. Neither
 * adding extensions with `client` component only cause other components to
 * recompute.
 */
declare class MergedExtensionsList {
  private head?;
  private constructor();
  static empty(): MergedExtensionsList;
  static single(extension: ExtensionArgs): MergedExtensionsList;
  isEmpty(): boolean;
  append(extension: ExtensionArgs): MergedExtensionsList;
  getAllComputedFields(dmmfModelName: string): ComputedFieldsMap | undefined;
  getAllClientExtensions(): ClientArg | undefined;
  getAllModelExtensions(dmmfModelName: string): ModelArg | undefined;
  getAllQueryCallbacks(jsModelName: string, operation: string): any;
  getAllBatchQueryCallbacks(): BatchQueryOptionsCb[];
}
declare type MergeExtArgs<TypeMap extends TypeMapDef, ExtArgs extends Record<any, any>, Args$1 extends Record<any, any>> = ComputeDeep<ExtArgs & Args$1 & AllModelsToStringIndex<TypeMap, Args$1, 'result'> & AllModelsToStringIndex<TypeMap, Args$1, 'model'>>;
declare type MiddlewareArgsMapper<RequestArgs, MiddlewareArgs> = {
  requestArgsToMiddlewareArgs(requestArgs: RequestArgs): MiddlewareArgs;
  middlewareArgsToRequestArgs(middlewareArgs: MiddlewareArgs): RequestArgs;
};
declare type Model = ReadonlyDeep_2<{
  name: string;
  dbName: string | null;
  schema: string | null;
  fields: Field[];
  uniqueFields: string[][];
  uniqueIndexes: uniqueIndex[];
  documentation?: string;
  primaryKey: PrimaryKey | null;
  isGenerated?: boolean;
}>;
declare enum ModelAction {
  findUnique = "findUnique",
  findUniqueOrThrow = "findUniqueOrThrow",
  findFirst = "findFirst",
  findFirstOrThrow = "findFirstOrThrow",
  findMany = "findMany",
  create = "create",
  createMany = "createMany",
  createManyAndReturn = "createManyAndReturn",
  update = "update",
  updateMany = "updateMany",
  updateManyAndReturn = "updateManyAndReturn",
  upsert = "upsert",
  delete = "delete",
  deleteMany = "deleteMany",
  groupBy = "groupBy",
  count = "count",
  // TODO: count does not actually exist in DMMF
  aggregate = "aggregate",
  findRaw = "findRaw",
  aggregateRaw = "aggregateRaw",
}
declare type ModelArg = { [MethodName in string]: unknown };
declare type ModelArgs = {
  model: { [ModelName in string]: ModelArg };
};
declare type ModelKey<TypeMap extends TypeMapDef, M extends PropertyKey> = M extends keyof TypeMap['model'] ? M : Capitalize<M & string>;
declare type ModelMapping = ReadonlyDeep_2<{
  model: string;
  plural: string;
  findUnique?: string | null;
  findUniqueOrThrow?: string | null;
  findFirst?: string | null;
  findFirstOrThrow?: string | null;
  findMany?: string | null;
  create?: string | null;
  createMany?: string | null;
  createManyAndReturn?: string | null;
  update?: string | null;
  updateMany?: string | null;
  updateManyAndReturn?: string | null;
  upsert?: string | null;
  delete?: string | null;
  deleteMany?: string | null;
  aggregate?: string | null;
  groupBy?: string | null;
  count?: string | null;
  findRaw?: string | null;
  aggregateRaw?: string | null;
}>;
declare type ModelQueryOptionsCb = (args: ModelQueryOptionsCbArgs) => Promise<any>;
declare type ModelQueryOptionsCbArgs = {
  model: string;
  operation: string;
  args: JsArgs;
  query: (args: JsArgs) => Promise<unknown>;
};
declare type MultiBatchResponse = {
  type: 'multi';
  plans: QueryPlanNode[];
};
declare type NameArgs = {
  name?: string;
};
declare type Narrow<A> = { [K in keyof A]: A[K] extends Function ? A[K] : Narrow<A[K]> } | (A extends Narrowable ? A : never);
declare type Narrowable = string | number | bigint | boolean | [];
declare type NeverToUnknown<T$1> = [T$1] extends [never] ? unknown : T$1;
declare const officialPrismaAdapters: readonly ["@prisma/adapter-planetscale", "@prisma/adapter-neon", "@prisma/adapter-libsql", "@prisma/adapter-better-sqlite3", "@prisma/adapter-d1", "@prisma/adapter-pg", "@prisma/adapter-mssql", "@prisma/adapter-mariadb"];
declare type Omission = Record<string, boolean | Skip>;
declare type Omit_2<T$1, K$1 extends string | number | symbol> = { [P in keyof T$1 as P extends K$1 ? never : P]: T$1[P] };
declare type OmitValue<Omit$1, Key$1> = Key$1 extends keyof Omit$1 ? Omit$1[Key$1] : false;
declare type Operation = 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'aggregate' | 'count' | 'groupBy' | '$queryRaw' | '$executeRaw' | '$queryRawUnsafe' | '$executeRawUnsafe' | 'findRaw' | 'aggregateRaw' | '$runCommandRaw';
declare type OperationPayload = {
  name: string;
  scalars: { [ScalarName in string]: unknown };
  objects: { [ObjectName in string]: unknown };
  composites: { [CompositeName in string]: unknown };
};
declare type Optional<O$1, K$1 extends keyof any = keyof O$1> = { [P in K$1 & keyof O$1]?: O$1[P] } & { [P in Exclude<keyof O$1, K$1>]: O$1[P] };
declare type OptionalFlat$1<T$1> = { [K in keyof T$1]?: T$1[K] };
declare type OptionalKeys<O$1> = { [K in keyof O$1]-?: {} extends Pick_2<O$1, K> ? K : never }[keyof O$1];
declare type Options = {
  /** Timeout for starting the transaction */
  maxWait?: number;
  /** Timeout for the transaction body */
  timeout?: number;
  /** Transaction isolation level */
  isolationLevel?: IsolationLevel_2;
  /**
   * Used for nested interactive transactions. When provided, the engine may
   * re-use an existing open transaction instead of opening a new one.
   */
  newTxId?: string;
};
declare type Or$1<A extends 1 | 0, B extends 1 | 0> = {
  0: {
    0: 0;
    1: 1;
  };
  1: {
    0: 1;
    1: 1;
  };
}[A][B];
declare type OtherOperationMappings = ReadonlyDeep_2<{
  read: string[];
  write: string[];
}>;
declare type OutputType = ReadonlyDeep_2<{
  name: string;
  fields: SchemaField[];
}>;
declare type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
declare type Pagination = {
  cursor: Record<string, unknown> | null;
  take: number | null;
  skip: number | null;
};
declare function Param<$Type, $Value extends string>(name: $Value): Param<$Type, $Value>;
declare type Param<out $Type, $Value extends string> = {
  readonly name: $Value;
};
declare type PatchFlat<O1, O2> = O1 & Omit_2<O2, keyof O1>;
declare type Path<O$1, P$1, Default = never> = O$1 extends unknown ? P$1 extends [infer K, ...infer R] ? K extends keyof O$1 ? Path<O$1[K], R> : Default : O$1 : never;
declare type Payload<T$1, F extends Operation = never> = T$1 extends {
  [K: symbol]: {
    types: {
      payload: any;
    };
  };
} ? T$1[symbol]['types']['payload'] : any;
declare type PayloadToResult<P$1, O$1 extends Record_2<any, any> = RenameAndNestPayloadKeys<P$1>> = { [K in keyof O$1]?: O$1[K][K] extends any[] ? PayloadToResult<O$1[K][K][number]>[] : O$1[K][K] extends object ? PayloadToResult<O$1[K][K]> : O$1[K][K] };
declare type Pick_2<T$1, K$1 extends string | number | symbol> = { [P in keyof T$1 as P extends K$1 ? P : never]: T$1[P] };
declare interface PlaceholderFormat {
  prefix: string;
  hasNumbering: boolean;
}
declare type PrimaryKey = ReadonlyDeep_2<{
  name: string | null;
  fields: string[];
}>;
/**
 * Since Prisma 7, a PrismaClient needs either an adapter or an accelerateUrl.
 * The two options are mutually exclusive.
 */
declare type PrismaClientMutuallyExclusiveOptions = {
  /**
   * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
   */
  adapter: SqlDriverAdapterFactory;
  accelerateUrl?: never;
} | {
  /**
   * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
   */
  accelerateUrl: string;
  adapter?: never;
};
declare type PrismaClientOptions = PrismaClientMutuallyExclusiveOptions & {
  /**
   * @default "colorless"
   */
  errorFormat?: ErrorFormat$1;
  /**
   * The default values for Transaction options
   * maxWait ?= 2000
   * timeout ?= 5000
   */
  transactionOptions?: Transaction_2.Options;
  /**
   * @example
   * \`\`\`
   * // Defaults to stdout
   * log: ['query', 'info', 'warn']
   *
   * // Emit as events
   * log: [
   *  { emit: 'stdout', level: 'query' },
   *  { emit: 'stdout', level: 'info' },
   *  { emit: 'stdout', level: 'warn' }
   * ]
   * \`\`\`
   * Read more in our [docs](https://pris.ly/d/logging).
   */
  log?: Array<LogLevel$1 | LogDefinition$1>;
  omit?: GlobalOmitOptions;
  /**
   * SQL commenter plugins that add metadata to SQL queries as comments.
   * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
   *
   * @example
   * ```ts
   * new PrismaClient({
   *   adapter: new PrismaPg({ connectionString }),
   *   comments: [
   *     traceContext(),
   *     queryInsights(),
   *   ],
   * })
   * ```
   */
  comments?: SqlCommenterPlugin[];
  /**
   * @internal
   * You probably don't want to use this. \`__internal\` is used by internal tooling.
   */
  __internal?: {
    debug?: boolean;
    /** This can be used for testing purposes */
    configOverride?: (config: GetPrismaClientConfig) => GetPrismaClientConfig;
  };
};
declare type PrismaOperationSpec<TArgs, TAction = string> = {
  args: TArgs;
  action: TAction;
  model: string;
};
declare interface PrismaPromise<T$1> extends Promise<T$1> {
  [Symbol.toStringTag]: 'PrismaPromise';
}
/**
 * Prisma's `Promise` that is backwards-compatible. All additions on top of the
 * original `Promise` are optional so that it can be backwards-compatible.
 * @see [[createPrismaPromise]]
 */
declare interface PrismaPromise_2<TResult, TSpec extends PrismaOperationSpec<unknown> = any> extends Promise<TResult> {
  get spec(): TSpec;
  /**
   * Extension of the original `.then` function
   * @param onfulfilled same as regular promises
   * @param onrejected same as regular promises
   * @param transaction transaction options
   */
  then<R1 = TResult, R2 = never>(onfulfilled?: (value: TResult) => R1 | PromiseLike<R1>, onrejected?: (error: unknown) => R2 | PromiseLike<R2>, transaction?: PrismaPromiseTransaction): Promise<R1 | R2>;
  /**
   * Extension of the original `.catch` function
   * @param onrejected same as regular promises
   * @param transaction transaction options
   */
  catch<R$1 = never>(onrejected?: ((reason: any) => R$1 | PromiseLike<R$1>) | undefined | null, transaction?: PrismaPromiseTransaction): Promise<TResult | R$1>;
  /**
   * Extension of the original `.finally` function
   * @param onfinally same as regular promises
   * @param transaction transaction options
   */
  finally(onfinally?: (() => void) | undefined | null, transaction?: PrismaPromiseTransaction): Promise<TResult>;
  /**
   * Called when executing a batch of regular tx
   * @param transaction transaction options for batch tx
   */
  requestTransaction?(transaction: PrismaPromiseBatchTransaction): PromiseLike<unknown>;
}
declare type PrismaPromiseBatchTransaction = {
  kind: 'batch';
  id: number;
  isolationLevel?: IsolationLevel_2;
  index: number;
  lock: PromiseLike<void>;
};
declare type PrismaPromiseCallback = (transaction?: PrismaPromiseTransaction) => Promise<unknown>;

/**
 * Creates a [[PrismaPromise]]. It is Prisma's implementation of `Promise` which
 * is essentially a proxy for `Promise`. All the transaction-compatible client
 * methods return one, this allows for pre-preparing queries without executing
 * them until `.then` is called. It's the foundation of Prisma's query batching.
 * @param callback that will be wrapped within our promise implementation
 * @see [[PrismaPromise]]
 * @returns
 */
declare type PrismaPromiseFactory = <T$1 extends PrismaOperationSpec<unknown>>(callback: PrismaPromiseCallback, op?: T$1) => PrismaPromise_2<unknown>;
declare type PrismaPromiseInteractiveTransaction<PayloadType = unknown> = {
  kind: 'itx';
  id: string;
  payload: PayloadType;
};
declare type PrismaPromiseTransaction<PayloadType = unknown> = PrismaPromiseBatchTransaction | PrismaPromiseInteractiveTransaction<PayloadType>;
declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator;
declare type PrismaValueGenerator = {
  prisma__type: 'generatorCall';
  prisma__value: {
    name: string;
    args: PrismaValue[];
  };
};
declare type PrismaValuePlaceholder = {
  prisma__type: 'param';
  prisma__value: {
    name: string;
    type: string;
  };
};
declare const PrivateResultType: unique symbol;
declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver';
declare namespace Public {
  export { validator };
}
declare namespace Public_2 {
  export { Args, Result, Payload, PrismaPromise, Operation, Exact };
}
declare type Query = ReadonlyDeep_2<{
  name: string;
  args: SchemaArg[];
  output: QueryOutput;
}>;
declare interface Queryable<Query$1, Result$1> extends AdapterInfo {
  /**
   * Execute a query and return its result.
   */
  queryRaw(params: Query$1): Promise<Result$1>;
  /**
   * Execute a query and return the number of affected rows.
   */
  executeRaw(params: Query$1): Promise<number>;
}
declare type QueryCompiler = {
  compile(request: string): {};
  compileBatch(batchRequest: string): BatchResponse;
  free(): void;
};
declare interface QueryCompilerConstructor {
  new (options: QueryCompilerOptions): QueryCompiler;
}
declare type QueryCompilerOptions = {
  datamodel: string;
  provider: Provider;
  connectionInfo: ConnectionInfo;
};
declare type QueryEngineResultData<T$1> = {
  data: T$1;
};
declare type QueryEvent = {
  timestamp: Date;
  query: string;
  params: string;
  duration: number;
  target: string;
};
declare type QueryEventType = 'query';
declare type QueryIntrospectionBuiltinType = 'int' | 'bigint' | 'float' | 'double' | 'string' | 'enum' | 'bytes' | 'bool' | 'char' | 'decimal' | 'json' | 'xml' | 'uuid' | 'datetime' | 'date' | 'time' | 'int-array' | 'bigint-array' | 'float-array' | 'double-array' | 'string-array' | 'char-array' | 'bytes-array' | 'bool-array' | 'decimal-array' | 'json-array' | 'xml-array' | 'uuid-array' | 'datetime-array' | 'date-array' | 'time-array' | 'null' | 'unknown';
declare type QueryMiddlewareParams = {
  /** The model this is executed on */
  model?: string;
  /** The action that is being handled */
  action: Action;
  /** TODO what is this */
  dataPath: string[];
  /** TODO what is this */
  runInTransaction: boolean;
  args?: UserArgs_2;
};
declare type QueryOptions = {
  query: { [ModelName in string]: { [ModelAction in string]: ModelQueryOptionsCb } | QueryOptionsCb };
};
declare type QueryOptionsCb = (args: QueryOptionsCbArgs) => Promise<any>;
declare type QueryOptionsCbArgs = {
  model?: string;
  operation: string;
  args: JsArgs | RawQueryArgs;
  query: (args: JsArgs | RawQueryArgs) => Promise<unknown>;
};
declare type QueryOutput = ReadonlyDeep_2<{
  name: string;
  isRequired: boolean;
  isList: boolean;
}>;
declare type QueryPlanBinding = {
  name: string;
  expr: QueryPlanNode;
};
declare type QueryPlanDbQuery = {
  type: 'rawSql';
  sql: string;
  args: PrismaValue[];
  argTypes: ArgType[];
} | {
  type: 'templateSql';
  fragments: Fragment[];
  placeholderFormat: PlaceholderFormat;
  args: PrismaValue[];
  argTypes: DynamicArgType[];
  chunkable: boolean;
};
declare type QueryPlanNode = {
  type: 'value';
  args: PrismaValue;
} | {
  type: 'seq';
  args: QueryPlanNode[];
} | {
  type: 'get';
  args: {
    name: string;
  };
} | {
  type: 'let';
  args: {
    bindings: QueryPlanBinding[];
    expr: QueryPlanNode;
  };
} | {
  type: 'getFirstNonEmpty';
  args: {
    names: string[];
  };
} | {
  type: 'query';
  args: QueryPlanDbQuery;
} | {
  type: 'execute';
  args: QueryPlanDbQuery;
} | {
  type: 'reverse';
  args: QueryPlanNode;
} | {
  type: 'sum';
  args: QueryPlanNode[];
} | {
  type: 'concat';
  args: QueryPlanNode[];
} | {
  type: 'unique';
  args: QueryPlanNode;
} | {
  type: 'required';
  args: QueryPlanNode;
} | {
  type: 'join';
  args: {
    parent: QueryPlanNode;
    children: JoinExpression[];
    canAssumeStrictEquality: boolean;
  };
} | {
  type: 'mapField';
  args: {
    field: string;
    records: QueryPlanNode;
  };
} | {
  type: 'transaction';
  args: QueryPlanNode;
} | {
  type: 'dataMap';
  args: {
    expr: QueryPlanNode;
    structure: ResultNode;
    enums: Record<string, Record<string, string>>;
  };
} | {
  type: 'validate';
  args: {
    expr: QueryPlanNode;
    rules: DataRule[];
  } & ValidationError;
} | {
  type: 'if';
  args: {
    value: QueryPlanNode;
    rule: DataRule;
    then: QueryPlanNode;
    else: QueryPlanNode;
  };
} | {
  type: 'unit';
} | {
  type: 'diff';
  args: {
    from: QueryPlanNode;
    to: QueryPlanNode;
    fields: string[];
  };
} | {
  type: 'initializeRecord';
  args: {
    expr: QueryPlanNode;
    fields: Record<string, FieldInitializer>;
  };
} | {
  type: 'mapRecord';
  args: {
    expr: QueryPlanNode;
    fields: Record<string, FieldOperation>;
  };
} | {
  type: 'process';
  args: {
    expr: QueryPlanNode;
    operations: InMemoryOps;
  };
};
declare type RawParameters = {
  __prismaRawParameters__: true;
  values: string;
};
declare type RawQueryArgs = Sql | UnknownTypedSql | [query: string, ...values: RawValue[]];
declare type RawResponse = {
  columns: string[];
  types: QueryIntrospectionBuiltinType[];
  rows: unknown[][];
};
declare type RawTaggedValue = {
  $type: 'Raw';
  value: unknown;
};
declare type ReadonlyDeep<T$1> = { readonly [K in keyof T$1]: ReadonlyDeep<T$1[K]> };
declare type ReadonlyDeep_2<O$1> = { +readonly [K in keyof O$1]: ReadonlyDeep_2<O$1[K]> };
declare type Record_2<T$1 extends string | number | symbol, U> = { [P in T$1]: U };
declare type RenameAndNestPayloadKeys<P$1> = { [K in keyof P$1 as K extends 'scalars' | 'objects' | 'composites' ? keyof P$1[K] : never]: P$1[K] };
declare type RequestBatchOptions<InteractiveTransactionPayload> = {
  transaction?: TransactionOptions_2<InteractiveTransactionPayload>;
  traceparent?: string;
  numTry?: number;
  containsWrite: boolean;
  customDataProxyFetch?: AccelerateExtensionFetchDecorator;
};
declare class RequestHandler {
  client: Client;
  dataloader: DataLoader<RequestParams>;
  private logEmitter?;
  constructor(client: Client, logEmitter?: LogEmitter);
  request(params: RequestParams): Promise<any>;
  mapQueryEngineResult({
    dataPath,
    unpacker
  }: RequestParams, response: QueryEngineResultData<any>): any;
  /**
   * Handles the error and logs it, logging the error is done synchronously waiting for the event
   * handlers to finish.
   */
  handleAndLogRequestError(params: HandleErrorParams): never;
  handleRequestError({
    error,
    clientMethod,
    callsite,
    transaction,
    args,
    modelName,
    globalOmit
  }: HandleErrorParams): never;
  sanitizeMessage(message: any): any;
  unpack(data: unknown, dataPath: string[], unpacker?: Unpacker): any;
  get [Symbol.toStringTag](): string;
}
declare type RequestOptions<InteractiveTransactionPayload> = {
  traceparent?: string;
  numTry?: number;
  interactiveTransaction?: InteractiveTransactionOptions<InteractiveTransactionPayload>;
  isWrite: boolean;
  customDataProxyFetch?: AccelerateExtensionFetchDecorator;
};
declare type RequestParams = {
  modelName?: string;
  action: Action;
  protocolQuery: JsonQuery;
  dataPath: string[];
  clientMethod: string;
  callsite?: CallSite;
  transaction?: PrismaPromiseTransaction;
  extensions: MergedExtensionsList;
  args?: any;
  headers?: Record<string, string>;
  unpacker?: Unpacker;
  otelParentCtx?: Context;
  otelChildCtx?: Context;
  globalOmit?: GlobalOmitOptions;
  customDataProxyFetch?: AccelerateExtensionFetchDecorator;
};
declare type RequiredExtensionArgs = NameArgs & ResultArgs & ModelArgs & ClientArgs & QueryOptions;
declare type RequiredKeys$1<O$1> = { [K in keyof O$1]-?: {} extends Pick_2<O$1, K> ? never : K }[keyof O$1];
declare type Result<T$1, A, F extends Operation> = T$1 extends {
  [K: symbol]: {
    types: {
      payload: any;
    };
  };
} ? GetResult<T$1[symbol]['types']['payload'], A, F> : GetResult<{
  composites: {};
  objects: {};
  scalars: {};
  name: '';
}, {}, F>;
declare type Result_2<T$1, A, F extends Operation> = Result<T$1, A, F>;
declare namespace Result_3 {
  export { Count, GetFindResult, SelectablePayloadFields, SelectField, DefaultSelection, UnwrapPayload, ApplyOmit, OmitValue, GetCountResult, Aggregate, GetAggregateResult, GetBatchResult, GetGroupByResult, GetResult, ExtractGlobalOmit };
}
declare type ResultArg = { [FieldName in string]: ResultFieldDefinition };
declare type ResultArgs = {
  result: { [ModelName in string]: ResultArg };
};
declare type ResultArgsFieldCompute = (model: any) => unknown;
declare type ResultFieldDefinition = {
  needs?: { [FieldName in string]: boolean };
  compute: ResultArgsFieldCompute;
};
declare type ResultNode = {
  type: 'affectedRows';
} | {
  type: 'object';
  fields: Record<string, ResultNode>;
  serializedName: string | null;
  skipNulls: boolean;
} | {
  type: 'field';
  dbName: string;
  fieldType: FieldType;
};
declare type Return<T$1> = T$1 extends ((...args: any[]) => infer R) ? R : T$1;
declare type RuntimeDataModel = {
  readonly models: Record<string, RuntimeModel>;
  readonly enums: Record<string, RuntimeEnum>;
  readonly types: Record<string, RuntimeModel>;
};
declare type RuntimeEnum = Omit<DMMF_2.DatamodelEnum, 'name'>;
declare type RuntimeModel = Omit<DMMF_2.Model, 'name'>;
declare type RuntimeName = 'workerd' | 'deno' | 'netlify' | 'node' | 'bun' | 'edge-light' | '';
declare type Schema = ReadonlyDeep_2<{
  rootQueryType?: string;
  rootMutationType?: string;
  inputObjectTypes: {
    model?: InputType[];
    prisma?: InputType[];
  };
  outputObjectTypes: {
    model: OutputType[];
    prisma: OutputType[];
  };
  enumTypes: {
    model?: SchemaEnum[];
    prisma: SchemaEnum[];
  };
  fieldRefTypes: {
    prisma?: FieldRefType[];
  };
}>;
declare type SchemaArg = ReadonlyDeep_2<{
  name: string;
  comment?: string;
  isNullable: boolean;
  isRequired: boolean;
  inputTypes: InputTypeRef[];
  isParameterizable: boolean;
  requiresOtherFields?: string[];
  deprecation?: Deprecation;
}>;
declare type SchemaEnum = ReadonlyDeep_2<{
  name: string;
  values: string[];
}>;
declare type SchemaField = ReadonlyDeep_2<{
  name: string;
  isNullable?: boolean;
  outputType: OutputTypeRef;
  args: SchemaArg[];
  deprecation?: Deprecation;
  documentation?: string;
}>;
declare type Select<T$1, U> = T$1 extends U ? T$1 : never;
declare type SelectablePayloadFields<K$1 extends PropertyKey, O$1> = {
  objects: { [k in K$1]: O$1 };
} | {
  composites: { [k in K$1]: O$1 };
};
declare type SelectField<P$1 extends SelectablePayloadFields<any, any>, K$1 extends PropertyKey> = P$1 extends {
  objects: Record<K$1, any>;
} ? P$1['objects'][K$1] : P$1 extends {
  composites: Record<K$1, any>;
} ? P$1['composites'][K$1] : never;
declare type Selection_2 = Record<string, boolean | Skip | JsArgs>;
/**
 * Serialized format stored in the generated client.
 */
declare interface SerializedParamGraph {
  /** String table (field names, enum names, root keys) */
  strings: string[];
  /** Base64url-encoded binary blob for structural data */
  graph: string;
}
declare function serializeJsonQuery({
  modelName,
  action,
  args,
  runtimeDataModel,
  extensions,
  callsite,
  clientMethod,
  errorFormat,
  clientVersion,
  previewFeatures,
  globalOmit,
  wrapRawValues
}: SerializeParams): JsonQuery;
declare type SerializeParams = {
  runtimeDataModel: RuntimeDataModel;
  modelName?: string;
  action: Action;
  args?: JsArgs;
  extensions?: MergedExtensionsList;
  callsite?: CallSite;
  clientMethod: string;
  clientVersion: string;
  errorFormat: ErrorFormat$1;
  previewFeatures: string[];
  globalOmit?: GlobalOmitOptions;
  wrapRawValues?: boolean;
};
declare class Skip {
  constructor(param?: symbol);
  ifUndefined<T$1>(value: T$1 | undefined): T$1 | Skip;
}
declare const skip: Skip;
declare type SortOrder$1 = 'asc' | 'desc';

/**
 * An interface that represents a span. A span represents a single operation
 * within a trace. Examples of span might include remote procedure calls or a
 * in-process function calls to sub-components. A Trace has a single, top-level
 * "root" Span that in turn may have zero or more child Spans, which in turn
 * may have children.
 *
 * Spans are created by the {@link Tracer.startSpan} method.
 */
declare interface Span {
  /**
   * Returns the {@link SpanContext} object associated with this Span.
   *
   * Get an immutable, serializable identifier for this span that can be used
   * to create new child spans. Returned SpanContext is usable even after the
   * span ends.
   *
   * @returns the SpanContext object associated with this Span.
   */
  spanContext(): SpanContext;
  /**
   * Sets an attribute to the span.
   *
   * Sets a single Attribute with the key and value passed as arguments.
   *
   * @param key the key for this attribute.
   * @param value the value for this attribute. Setting a value null or
   *              undefined is invalid and will result in undefined behavior.
   */
  setAttribute(key: string, value: SpanAttributeValue): this;
  /**
   * Sets attributes to the span.
   *
   * @param attributes the attributes that will be added.
   *                   null or undefined attribute values
   *                   are invalid and will result in undefined behavior.
   */
  setAttributes(attributes: SpanAttributes): this;
  /**
   * Adds an event to the Span.
   *
   * @param name the name of the event.
   * @param [attributesOrStartTime] the attributes that will be added; these are
   *     associated with this event. Can be also a start time
   *     if type is {@type TimeInput} and 3rd param is undefined
   * @param [startTime] start time of the event.
   */
  addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
  /**
   * Adds a single link to the span.
   *
   * Links added after the creation will not affect the sampling decision.
   * It is preferred span links be added at span creation.
   *
   * @param link the link to add.
   */
  addLink(link: Link): this;
  /**
   * Adds multiple links to the span.
   *
   * Links added after the creation will not affect the sampling decision.
   * It is preferred span links be added at span creation.
   *
   * @param links the links to add.
   */
  addLinks(links: Link[]): this;
  /**
   * Sets a status to the span. If used, this will override the default Span
   * status. Default is {@link SpanStatusCode.UNSET}. SetStatus overrides the value
   * of previous calls to SetStatus on the Span.
   *
   * @param status the SpanStatus to set.
   */
  setStatus(status: SpanStatus): this;
  /**
   * Updates the Span name.
   *
   * This will override the name provided via {@link Tracer.startSpan}.
   *
   * Upon this update, any sampling behavior based on Span name will depend on
   * the implementation.
   *
   * @param name the Span name.
   */
  updateName(name: string): this;
  /**
   * Marks the end of Span execution.
   *
   * Call to End of a Span MUST not have any effects on child spans. Those may
   * still be running and can be ended later.
   *
   * Do not return `this`. The Span generally should not be used after it
   * is ended so chaining is not desired in this context.
   *
   * @param [endTime] the time to set as Span's end time. If not provided,
   *     use the current time as the span's end time.
   */
  end(endTime?: TimeInput): void;
  /**
   * Returns the flag whether this span will be recorded.
   *
   * @returns true if this Span is active and recording information like events
   *     with the `AddEvent` operation and attributes using `setAttributes`.
   */
  isRecording(): boolean;
  /**
   * Sets exception as a span event
   * @param exception the exception the only accepted values are string or Error
   * @param [time] the time to set as Span's event time. If not provided,
   *     use the current time.
   */
  recordException(exception: Exception, time?: TimeInput): void;
}

/**
 * @deprecated please use {@link Attributes}
 */
declare type SpanAttributes = Attributes;

/**
 * @deprecated please use {@link AttributeValue}
 */
declare type SpanAttributeValue = AttributeValue;
declare type SpanCallback<R$1> = (span?: Span, context?: Context) => R$1;

/**
 * A SpanContext represents the portion of a {@link Span} which must be
 * serialized and propagated along side of a {@link Baggage}.
 */
declare interface SpanContext {
  /**
   * The ID of the trace that this span belongs to. It is worldwide unique
   * with practically sufficient probability by being made as 16 randomly
   * generated bytes, encoded as a 32 lowercase hex characters corresponding to
   * 128 bits.
   */
  traceId: string;
  /**
   * The ID of the Span. It is globally unique with practically sufficient
   * probability by being made as 8 randomly generated bytes, encoded as a 16
   * lowercase hex characters corresponding to 64 bits.
   */
  spanId: string;
  /**
   * Only true if the SpanContext was propagated from a remote parent.
   */
  isRemote?: boolean;
  /**
   * Trace flags to propagate.
   *
   * It is represented as 1 byte (bitmap). Bit to represent whether trace is
   * sampled or not. When set, the least significant bit documents that the
   * caller may have recorded trace data. A caller who does not record trace
   * data out-of-band leaves this flag unset.
   *
   * see {@link TraceFlags} for valid flag values.
   */
  traceFlags: number;
  /**
   * Tracing-system-specific info to propagate.
   *
   * The tracestate field value is a `list` as defined below. The `list` is a
   * series of `list-members` separated by commas `,`, and a list-member is a
   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
   * surrounding `list-members` are ignored. There can be a maximum of 32
   * `list-members` in a `list`.
   * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
   *
   * Examples:
   *     Single tracing system (generic format):
   *         tracestate: rojo=00f067aa0ba902b7
   *     Multiple tracing systems (with different formatting):
   *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
   */
  traceState?: TraceState;
}
declare enum SpanKind {
  /** Default value. Indicates that the span is used internally. */
  INTERNAL = 0,
  /**
   * Indicates that the span covers server-side handling of an RPC or other
   * remote request.
   */
  SERVER = 1,
  /**
   * Indicates that the span covers the client-side wrapper around an RPC or
   * other remote request.
   */
  CLIENT = 2,
  /**
   * Indicates that the span describes producer sending a message to a
   * broker. Unlike client and server, there is no direct critical path latency
   * relationship between producer and consumer spans.
   */
  PRODUCER = 3,
  /**
   * Indicates that the span describes consumer receiving a message from a
   * broker. Unlike client and server, there is no direct critical path latency
   * relationship between producer and consumer spans.
   */
  CONSUMER = 4,
}

/**
 * Options needed for span creation
 */
declare interface SpanOptions {
  /**
   * The SpanKind of a span
   * @default {@link SpanKind.INTERNAL}
   */
  kind?: SpanKind;
  /** A span's attributes */
  attributes?: SpanAttributes;
  /** {@link Link}s span to other spans */
  links?: Link[];
  /** A manually specified start time for the created `Span` object. */
  startTime?: TimeInput;
  /** The new span should be a root span. (Ignore parent from context). */
  root?: boolean;
}
declare interface SpanStatus {
  /** The status code of this message. */
  code: SpanStatusCode;
  /** A developer-facing error message. */
  message?: string;
}

/**
 * An enumeration of status codes.
 */
declare enum SpanStatusCode {
  /**
   * The default status.
   */
  UNSET = 0,
  /**
   * The operation has been validated by an Application developer or
   * Operator to have completed successfully.
   */
  OK = 1,
  /**
   * The operation contains an error.
   */
  ERROR = 2,
}
/**
 * Information about a compacted batch query (e.g. multiple independent
 * `findUnique` queries automatically merged into a single `SELECT` SQL
 * statement).
 */
declare interface SqlCommenterCompactedQueryInfo {
  /**
   * The model name (e.g., "User", "Post").
   */
  readonly modelName: string;
  /**
   * The Prisma operation (e.g., "findUnique").
   */
  readonly action: SqlCommenterQueryAction;
  /**
   * The full query objects (selections, arguments, etc.).
   * Specifics of the query representation are not part of the public API yet.
   */
  readonly queries: ReadonlyArray<unknown>;
}

/**
 * Context provided to SQL commenter plugins.
 */
declare interface SqlCommenterContext {
  /**
   * Information about the Prisma query being executed.
   */
  readonly query: SqlCommenterQueryInfo;
  /**
   * Raw SQL query generated from this Prisma query.
   *
   * It is always available when `PrismaClient` connects to the database and
   * renders SQL queries directly.
   *
   * When using Prisma Accelerate, SQL rendering happens on Accelerate side and the raw
   * SQL strings are not yet available when SQL commenter plugins are executed.
   */
  readonly sql?: string;
}
/**
 * A SQL commenter plugin that returns key-value pairs to be added as comments.
 * Return an empty object to add no comments. Keys with undefined values will be omitted.
 *
 * @example
 * ```ts
 * const myPlugin: SqlCommenterPlugin = (context) => {
 *   return {
 *     application: 'my-app',
 *     model: context.query.modelName ?? 'raw',
 *     // Conditional key - will be omitted if ctx.sql is undefined
 *     sqlLength: context.sql ? String(context.sql.length) : undefined,
 *   }
 * }
 * ```
 */
declare interface SqlCommenterPlugin {
  (context: SqlCommenterContext): SqlCommenterTags;
}
/**
 * Prisma query type corresponding to this SQL query.
 */
declare type SqlCommenterQueryAction = JsonQueryAction;

/**
 * Information about the query or queries being executed.
 *
 * - `single`: A single query is being executed
 * - `compacted`: Multiple queries have been compacted into a single SQL statement
 */
declare type SqlCommenterQueryInfo = ({
  readonly type: 'single';
} & SqlCommenterSingleQueryInfo) | ({
  readonly type: 'compacted';
} & SqlCommenterCompactedQueryInfo);
/**
 * Information about a single Prisma query.
 */
declare interface SqlCommenterSingleQueryInfo {
  /**
   * The model name (e.g., "User", "Post"). Undefined for raw queries.
   */
  readonly modelName?: string;
  /**
   * The Prisma operation (e.g., "findMany", "createOne", "queryRaw").
   */
  readonly action: SqlCommenterQueryAction;
  /**
   * The full query object (selection, arguments, etc.).
   * Specifics of the query representation are not part of the public API yet.
   */
  readonly query: unknown;
}
/**
 * Key-value pairs to add as SQL comments.
 * Keys with undefined values will be omitted from the final comment.
 */
declare type SqlCommenterTags = {
  readonly [key: string]: string | undefined;
};
declare interface SqlDriverAdapter extends SqlQueryable {
  /**
   * Execute multiple SQL statements separated by semicolon.
   */
  executeScript(script: string): Promise<void>;
  /**
   * Start new transaction.
   */
  startTransaction(isolationLevel?: IsolationLevel): Promise<Transaction>;
  /**
   * Optional method that returns extra connection info
   */
  getConnectionInfo?(): ConnectionInfo;
  /**
   * Dispose of the connection and release any resources.
   */
  dispose(): Promise<void>;
}
declare interface SqlDriverAdapterFactory extends DriverAdapterFactory<SqlQuery, SqlResultSet> {
  connect(): Promise<SqlDriverAdapter>;
}
declare type SqlQuery = {
  sql: string;
  args: Array<unknown>;
  argTypes: Array<ArgType>;
};
declare interface SqlQueryable extends Queryable<SqlQuery, SqlResultSet> {}
declare interface SqlResultSet {
  /**
   * List of column types appearing in a database query, in the same order as `columnNames`.
   * They are used within the Query Engine to convert values from JS to Quaint values.
   */
  columnTypes: Array<ColumnType>;
  /**
   * List of column names appearing in a database query, in the same order as `columnTypes`.
   */
  columnNames: Array<string>;
  /**
   * List of rows retrieved from a database query.
   * Each row is a list of values, whose length matches `columnNames` and `columnTypes`.
   */
  rows: Array<Array<unknown>>;
  /**
   * The last ID of an `INSERT` statement, if any.
   * This is required for `AUTO_INCREMENT` columns in databases based on MySQL and SQLite.
   */
  lastInsertId?: string;
}
/**
 * Defines TimeInput.
 *
 * hrtime, epoch milliseconds, performance.now() or Date
 */
declare type TimeInput = HrTime_2 | number | Date;
declare type ToTuple<T$1> = T$1 extends any[] ? T$1 : [T$1];
declare interface TraceState {
  /**
   * Create a new TraceState which inherits from this TraceState and has the
   * given key set.
   * The new entry will always be added in the front of the list of states.
   *
   * @param key key of the TraceState entry.
   * @param value value of the TraceState entry.
   */
  set(key: string, value: string): TraceState;
  /**
   * Return a new TraceState which inherits from this TraceState but does not
   * contain the given key.
   *
   * @param key the key for the TraceState entry to be removed.
   */
  unset(key: string): TraceState;
  /**
   * Returns the value to which the specified key is mapped, or `undefined` if
   * this map contains no mapping for the key.
   *
   * @param key with which the specified value is to be associated.
   * @returns the value to which the specified key is mapped, or `undefined` if
   *     this map contains no mapping for the key.
   */
  get(key: string): string | undefined;
  /**
   * Serializes the TraceState to a `list` as defined below. The `list` is a
   * series of `list-members` separated by commas `,`, and a list-member is a
   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
   * surrounding `list-members` are ignored. There can be a maximum of 32
   * `list-members` in a `list`.
   *
   * @returns the serialized string.
   */
  serialize(): string;
}
declare interface TracingHelper {
  isEnabled(): boolean;
  getTraceParent(context?: Context): string;
  dispatchEngineSpans(spans: EngineSpan[]): void;
  getActiveContext(): Context | undefined;
  runInChildSpan<R$1>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R$1>): R$1;
}
declare interface Transaction extends AdapterInfo, SqlQueryable {
  /**
   * Transaction options.
   */
  readonly options: TransactionOptions;
  /**
   * Commit the transaction.
   */
  commit(): Promise<void>;
  /**
   * Roll back the transaction.
   */
  rollback(): Promise<void>;
  /**
   * Creates a savepoint within the currently running transaction.
   */
  createSavepoint?(name: string): Promise<void>;
  /**
   * Rolls back transaction state to a previously created savepoint.
   */
  rollbackToSavepoint?(name: string): Promise<void>;
  /**
   * Releases a previously created savepoint. Optional because not every connector supports this operation.
   */
  releaseSavepoint?(name: string): Promise<void>;
}
declare namespace Transaction_2 {
  export { IsolationLevel_2 as IsolationLevel, Options, InteractiveTransactionInfo, TransactionHeaders };
}
declare type TransactionHeaders = {
  traceparent?: string;
};
declare type TransactionOptions = {
  usePhantomQuery: boolean;
};
declare type TransactionOptions_2<InteractiveTransactionPayload> = {
  kind: 'itx';
  options: InteractiveTransactionOptions<InteractiveTransactionPayload>;
} | {
  kind: 'batch';
  options: BatchTransactionOptions;
};
declare class TypedSql<Values extends readonly unknown[], Result$1> {
  [PrivateResultType]: Result$1;
  constructor(sql: string, values: Values);
  get sql(): string;
  get values(): Values;
}
declare type TypeMapCbDef = Fn<{
  extArgs: InternalArgs;
}, TypeMapDef>;
/** Shared */
declare type TypeMapDef = Record<any, any>;
declare type TypeRef<AllowedLocations extends FieldLocation> = {
  isList: boolean;
  type: string;
  location: AllowedLocations;
  namespace?: FieldNamespace;
};
declare namespace Types {
  export { Result_3 as Result, Extensions_2 as Extensions, Utils, Public_2 as Public, isSkip, Skip, skip, UnknownTypedSql, OperationPayload as Payload };
}
declare type uniqueIndex = ReadonlyDeep_2<{
  name: string;
  fields: string[];
}>;
declare type UnknownTypedSql = TypedSql<unknown[], unknown>;
declare type Unpacker = (data: any) => any;
declare type UnwrapPayload<P$1> = {} extends P$1 ? unknown : { [K in keyof P$1]: P$1[K] extends {
  scalars: infer S;
  composites: infer C;
}[] ? Array<S & UnwrapPayload<C>> : P$1[K] extends {
  scalars: infer S;
  composites: infer C;
} | null ? S & UnwrapPayload<C> | Select<P$1[K], null> : never };
declare type UnwrapPromise<P$1> = P$1 extends Promise<infer R> ? R : P$1;
declare type UnwrapTuple<Tuple extends readonly unknown[]> = { [K in keyof Tuple]: K extends `${number}` ? Tuple[K] extends PrismaPromise<infer X> ? X : UnwrapPromise<Tuple[K]> : UnwrapPromise<Tuple[K]> };
/**
 * Input that flows from the user into the Client.
 */
declare type UserArgs_2 = any;
declare namespace Utils {
  export { EmptyToUnknown, NeverToUnknown, PatchFlat, Omit_2 as Omit, Pick_2 as Pick, ComputeDeep, Compute, OptionalFlat$1 as OptionalFlat, ReadonlyDeep, Narrowable, Narrow, Exact, Cast, Record_2 as Record, UnwrapPromise, UnwrapTuple, Path, Fn, Call, RequiredKeys$1 as RequiredKeys, OptionalKeys, Optional, Return, ToTuple, RenameAndNestPayloadKeys, PayloadToResult, Select, Equals, Or$1 as Or, JsPromise };
}
declare type ValidationError = {
  errorIdentifier: 'RELATION_VIOLATION';
  context: {
    relation: string;
    modelA: string;
    modelB: string;
  };
} | {
  errorIdentifier: 'MISSING_RELATED_RECORD';
  context: {
    model: string;
    relation: string;
    relationType: string;
    operation: string;
    neededFor?: string;
  };
} | {
  errorIdentifier: 'MISSING_RECORD';
  context: {
    operation: string;
  };
} | {
  errorIdentifier: 'INCOMPLETE_CONNECT_INPUT';
  context: {
    expectedRows: number;
  };
} | {
  errorIdentifier: 'INCOMPLETE_CONNECT_OUTPUT';
  context: {
    expectedRows: number;
    relation: string;
    relationType: string;
  };
} | {
  errorIdentifier: 'RECORDS_NOT_CONNECTED';
  context: {
    relation: string;
    parent: string;
    child: string;
  };
};
declare function validator<V>(): <S$1>(select: Exact<S$1, V>) => S$1;
declare function validator<C$1, M extends Exclude<keyof C$1, `$${string}`>, O$1 extends keyof C$1[M] & Operation>(client: C$1, model: M, operation: O$1): <S$1>(select: Exact<S$1, Args<C$1[M], O$1>>) => S$1;
declare function validator<C$1, M extends Exclude<keyof C$1, `$${string}`>, O$1 extends keyof C$1[M] & Operation, P$1 extends keyof Args<C$1[M], O$1>>(client: C$1, model: M, operation: O$1, prop: P$1): <S$1>(select: Exact<S$1, Args<C$1[M], O$1>[P$1]>) => S$1;
declare const warnOnce: (key: string, message: string, ...args: unknown[]) => void;
/**
 * ##  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).
 */
declare 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$1 = 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$1 = 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$1 = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T$1>;

  /**
   * 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$1 = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T$1>;

  /**
   * 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$1 extends Prisma.PrismaPromise<any>[]>(arg: [...P$1], options?: {
    isolationLevel?: Prisma.TransactionIsolationLevel;
  }): $Utils.JsPromise<Types.Utils.UnwrapTuple<P$1>>;
  $transaction<R$1>(fn: (prisma: Omit<PrismaClient, ITXClientDenyList>) => $Utils.JsPromise<R$1>, options?: {
    maxWait?: number;
    timeout?: number;
    isolationLevel?: Prisma.TransactionIsolationLevel;
  }): $Utils.JsPromise<R$1>;
  $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>;
}
declare namespace Prisma {
  export import DMMF = runtime.DMMF;
  export type PrismaPromise<T$1> = $Public.PrismaPromise<T$1>;

  /**
   * 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 = 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$1 extends PromiseLike<any>> = T$1 extends PromiseLike<infer U> ? U : T$1;

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

  /**
   * From T, pick a set of properties whose keys are in the union K
   */
  type Prisma__Pick<T$1, K$1 extends keyof T$1> = { [P in K$1]: T$1[P] };
  export type Enumerable<T$1> = T$1 | Array<T$1>;
  export type RequiredKeys<T$1> = { [K in keyof T$1]-?: {} extends Prisma__Pick<T$1, K$1> ? never : K$1 }[keyof T$1];
  export type TruthyKeys<T$1> = keyof { [K in keyof T$1 as T$1[K$1] extends false | undefined | null ? never : K$1]: K$1 };
  export type TrueKeys<T$1> = TruthyKeys<Prisma__Pick<T$1, RequiredKeys<T$1>>>;

  /**
   * Subset
   * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
   */
  export type Subset<T$1, U> = { [key in keyof T$1]: key extends keyof U ? T$1[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$1, U> = { [key in keyof T$1]: key extends keyof U ? T$1[key] : never } & (T$1 extends SelectAndInclude ? 'Please either choose `select` or `include`.' : T$1 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$1, U, K$1> = { [key in keyof T$1]: key extends keyof U ? T$1[key] : never } & K$1;
  type Without<T$1, U> = { [P in Exclude<keyof T$1, 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$1, U> = T$1 extends object ? U extends object ? (Without<T$1, U> & U) | (Without<U, T$1> & T$1) : U : T$1;

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

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

  /**
   * From ts-toolbelt
   */

  type __Either<O$1 extends object, K$1 extends Key> = Omit<O$1, K$1> & {
    // Merge all but K
  [P in K$1]: Prisma__Pick<O$1, P & keyof O$1> // With K possibilities
  }[K$1];
  type EitherStrict<O$1 extends object, K$1 extends Key> = Strict<__Either<O$1, K$1>>;
  type EitherLoose<O$1 extends object, K$1 extends Key> = ComputeRaw<__Either<O$1, K$1>>;
  type _Either<O$1 extends object, K$1 extends Key, strict extends Boolean> = {
    1: EitherStrict<O$1, K$1>;
    0: EitherLoose<O$1, K$1>;
  }[strict];
  type Either<O$1 extends object, K$1 extends Key, strict extends Boolean = 1> = O$1 extends unknown ? _Either<O$1, K$1, strict> : never;
  export type Union = any;
  type PatchUndefined<O$1 extends object, O1 extends object> = { [K in keyof O$1]: O$1[K$1] extends undefined ? At<O1, K$1> : O$1[K$1] } & {};

  /** 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$1 extends object, O1 extends object> = { [K in keyof O$1]: K$1 extends keyof O1 ? O1[K$1] : O$1[K$1] } & {};
  type _Merge<U extends object> = IntersectOf<Overwrite<U, { [K in keyof U]-?: At<U, K$1> }>>;
  type Key = string | number | symbol;
  type AtBasic<O$1 extends object, K$1 extends Key> = K$1 extends keyof O$1 ? O$1[K$1] : never;
  type AtStrict<O$1 extends object, K$1 extends Key> = O$1[K$1 & keyof O$1];
  type AtLoose<O$1 extends object, K$1 extends Key> = O$1 extends unknown ? AtStrict<O$1, K$1> : never;
  export type At<O$1 extends object, K$1 extends Key, strict extends Boolean = 1> = {
    1: AtStrict<O$1, K$1>;
    0: AtLoose<O$1, K$1>;
  }[strict];
  export type ComputeRaw<A extends any> = A extends Function ? A : { [K in keyof A]: A[K$1] } & {};
  export type OptionalFlat<O$1> = { [K in keyof O$1]?: O$1[K$1] } & {};
  type _Record<K$1 extends keyof any, T$1> = { [P in K$1]: T$1 };

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

  // this type assumes the passed object is entirely optional
  type AtLeast<O$1 extends object, K$1 extends string> = NoExpand<O$1 extends unknown ? (K$1 extends keyof O$1 ? { [P in K$1]: O$1[P] } & O$1 : O$1) | { [P in keyof O$1 as P extends K$1 ? P : never]-?: O$1[P] } & O$1 : 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$1, O$1> = O$1 extends object ? { [P in keyof T$1]: P extends keyof O$1 ? O$1[P] : never } : never;
  type FieldPaths<T$1, U = Omit<T$1, '_avg' | '_sum' | '_count' | '_min' | '_max'>> = IsObject<T$1> extends True ? U : T$1;
  type GetHavingFields<T$1> = { [K in keyof T$1]: Or<Or<Extends<'OR', K$1>, Extends<'AND', K$1>>, Extends<'NOT', K$1>> 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$1[K$1] extends infer TK ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never> : never : {} extends FieldPaths<T$1[K$1]> ? never : K$1 }[keyof T$1];

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

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

  /**
   * Exclude all keys with underscores
   */
  type ExcludeUnderscoreKeys<T$1 extends string> = T$1 extends `_${string}` ? never : T$1;
  export type FieldRef<Model$1, FieldType$1> = FieldRef$1<Model$1, FieldType$1>;
  type FieldRefInputType<Model$1, FieldType$1> = Model$1 extends never ? never : FieldRef<Model$1, FieldType$1>;
  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$1 = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions$1;
    };
    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?: 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?: 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$1> = T$1 extends LogLevel ? T$1 : never;
  export type GetLogType<T$1> = CheckIsLogLevel<T$1 extends LogDefinition ? T$1['level'] : T$1>;
  export type GetEvents<T$1 extends any[]> = T$1 extends Array<LogLevel | LogDefinition> ? GetLogType<T$1[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, 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$1 extends RunAggregateArgs> = { [P in keyof T$1 & keyof AggregateRun]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateRun[P]> : GetScalarType<T$1[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$1 extends RunGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<RunGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof RunGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], RunGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | RunDefaultArgs> = $Result.GetResult<Prisma.$RunPayload, S$1>;
  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$1 = {}> {
    [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$1 extends RunFindUniqueArgs>(args: SelectSubset<T$1, RunFindUniqueArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunFindUniqueOrThrowArgs>(args: SelectSubset<T$1, RunFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunFindFirstArgs>(args?: SelectSubset<T$1, RunFindFirstArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunFindFirstOrThrowArgs>(args?: SelectSubset<T$1, RunFindFirstOrThrowArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunFindManyArgs>(args?: SelectSubset<T$1, RunFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunCreateArgs>(args: SelectSubset<T$1, RunCreateArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunCreateManyAndReturnArgs>(args?: SelectSubset<T$1, RunCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunDeleteArgs>(args: SelectSubset<T$1, RunDeleteArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunUpdateArgs>(args: SelectSubset<T$1, RunUpdateArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends RunUpdateManyAndReturnArgs>(args: SelectSubset<T$1, RunUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunUpsertArgs>(args: SelectSubset<T$1, RunUpsertArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunCountArgs>(args?: Subset<T$1, RunCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends RunAggregateArgs>(args: Subset<T$1, RunAggregateArgs>): Prisma.PrismaPromise<GetRunAggregateType<T$1>>;

    /**
     * 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$1 extends RunGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: RunGroupByArgs['orderBy'];
    } : {
      orderBy?: RunGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, RunGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRunGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    workItems<T$1 extends Run$workItemsArgs<ExtArgs> = {}>(args?: Subset<T$1, Run$workItemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | Null>;
    executionInstances<T$1 extends Run$executionInstancesArgs<ExtArgs> = {}>(args?: Subset<T$1, Run$executionInstancesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | Null>;
    slotProjection<T$1 extends Run$slotProjectionArgs<ExtArgs> = {}>(args?: Subset<T$1, Run$slotProjectionArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;
    testSuiteRun<T$1 extends Run$testSuiteRunArgs<ExtArgs> = {}>(args?: Subset<T$1, Run$testSuiteRunArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;
    testAssertions<T$1 extends Run$testAssertionsArgs<ExtArgs> = {}>(args?: Subset<T$1, Run$testAssertionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | Null>;
    workflowSnapshot<T$1 extends Run$workflowSnapshotArgs<ExtArgs> = {}>(args?: Subset<T$1, Run$workflowSnapshotArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends RunWorkItemAggregateArgs> = { [P in keyof T$1 & keyof AggregateRunWorkItem]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateRunWorkItem[P]> : GetScalarType<T$1[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$1 extends RunWorkItemGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<RunWorkItemGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof RunWorkItemGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], RunWorkItemGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | RunWorkItemDefaultArgs> = $Result.GetResult<Prisma.$RunWorkItemPayload, S$1>;
  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$1 = {}> {
    [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$1 extends RunWorkItemFindUniqueArgs>(args: SelectSubset<T$1, RunWorkItemFindUniqueArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemFindUniqueOrThrowArgs>(args: SelectSubset<T$1, RunWorkItemFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemFindFirstArgs>(args?: SelectSubset<T$1, RunWorkItemFindFirstArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemFindFirstOrThrowArgs>(args?: SelectSubset<T$1, RunWorkItemFindFirstOrThrowArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemFindManyArgs>(args?: SelectSubset<T$1, RunWorkItemFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunWorkItemCreateArgs>(args: SelectSubset<T$1, RunWorkItemCreateArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunWorkItemCreateManyAndReturnArgs>(args?: SelectSubset<T$1, RunWorkItemCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunWorkItemDeleteArgs>(args: SelectSubset<T$1, RunWorkItemDeleteArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemUpdateArgs>(args: SelectSubset<T$1, RunWorkItemUpdateArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunWorkItemUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends RunWorkItemUpdateManyAndReturnArgs>(args: SelectSubset<T$1, RunWorkItemUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunWorkItemUpsertArgs>(args: SelectSubset<T$1, RunWorkItemUpsertArgs<ExtArgs>>): Prisma__RunWorkItemClient<$Result.GetResult<Prisma.$RunWorkItemPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunWorkItemCountArgs>(args?: Subset<T$1, RunWorkItemCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends RunWorkItemAggregateArgs>(args: Subset<T$1, RunWorkItemAggregateArgs>): Prisma.PrismaPromise<GetRunWorkItemAggregateType<T$1>>;

    /**
     * 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$1 extends RunWorkItemGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: RunWorkItemGroupByArgs['orderBy'];
    } : {
      orderBy?: RunWorkItemGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, RunWorkItemGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRunWorkItemGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    run<T$1 extends RunDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, RunDefaultArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends ExecutionInstanceAggregateArgs> = { [P in keyof T$1 & keyof AggregateExecutionInstance]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateExecutionInstance[P]> : GetScalarType<T$1[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$1 extends ExecutionInstanceGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<ExecutionInstanceGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof ExecutionInstanceGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], ExecutionInstanceGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | ExecutionInstanceDefaultArgs> = $Result.GetResult<Prisma.$ExecutionInstancePayload, S$1>;
  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$1 = {}> {
    [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$1 extends ExecutionInstanceFindUniqueArgs>(args: SelectSubset<T$1, ExecutionInstanceFindUniqueArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceFindUniqueOrThrowArgs>(args: SelectSubset<T$1, ExecutionInstanceFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceFindFirstArgs>(args?: SelectSubset<T$1, ExecutionInstanceFindFirstArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceFindFirstOrThrowArgs>(args?: SelectSubset<T$1, ExecutionInstanceFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceFindManyArgs>(args?: SelectSubset<T$1, ExecutionInstanceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends ExecutionInstanceCreateArgs>(args: SelectSubset<T$1, ExecutionInstanceCreateArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends ExecutionInstanceCreateManyAndReturnArgs>(args?: SelectSubset<T$1, ExecutionInstanceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends ExecutionInstanceDeleteArgs>(args: SelectSubset<T$1, ExecutionInstanceDeleteArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceUpdateArgs>(args: SelectSubset<T$1, ExecutionInstanceUpdateArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends ExecutionInstanceUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends ExecutionInstanceUpdateManyAndReturnArgs>(args: SelectSubset<T$1, ExecutionInstanceUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends ExecutionInstanceUpsertArgs>(args: SelectSubset<T$1, ExecutionInstanceUpsertArgs<ExtArgs>>): Prisma__ExecutionInstanceClient<$Result.GetResult<Prisma.$ExecutionInstancePayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends ExecutionInstanceCountArgs>(args?: Subset<T$1, ExecutionInstanceCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends ExecutionInstanceAggregateArgs>(args: Subset<T$1, ExecutionInstanceAggregateArgs>): Prisma.PrismaPromise<GetExecutionInstanceAggregateType<T$1>>;

    /**
     * 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$1 extends ExecutionInstanceGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: ExecutionInstanceGroupByArgs['orderBy'];
    } : {
      orderBy?: ExecutionInstanceGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, ExecutionInstanceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExecutionInstanceGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    run<T$1 extends RunDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, RunDefaultArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends RunSlotProjectionAggregateArgs> = { [P in keyof T$1 & keyof AggregateRunSlotProjection]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateRunSlotProjection[P]> : GetScalarType<T$1[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$1 extends RunSlotProjectionGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<RunSlotProjectionGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof RunSlotProjectionGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], RunSlotProjectionGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | RunSlotProjectionDefaultArgs> = $Result.GetResult<Prisma.$RunSlotProjectionPayload, S$1>;
  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$1 = {}> {
    [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$1 extends RunSlotProjectionFindUniqueArgs>(args: SelectSubset<T$1, RunSlotProjectionFindUniqueArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionFindUniqueOrThrowArgs>(args: SelectSubset<T$1, RunSlotProjectionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionFindFirstArgs>(args?: SelectSubset<T$1, RunSlotProjectionFindFirstArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionFindFirstOrThrowArgs>(args?: SelectSubset<T$1, RunSlotProjectionFindFirstOrThrowArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionFindManyArgs>(args?: SelectSubset<T$1, RunSlotProjectionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunSlotProjectionCreateArgs>(args: SelectSubset<T$1, RunSlotProjectionCreateArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunSlotProjectionCreateManyAndReturnArgs>(args?: SelectSubset<T$1, RunSlotProjectionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunSlotProjectionDeleteArgs>(args: SelectSubset<T$1, RunSlotProjectionDeleteArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionUpdateArgs>(args: SelectSubset<T$1, RunSlotProjectionUpdateArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunSlotProjectionUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends RunSlotProjectionUpdateManyAndReturnArgs>(args: SelectSubset<T$1, RunSlotProjectionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunSlotProjectionUpsertArgs>(args: SelectSubset<T$1, RunSlotProjectionUpsertArgs<ExtArgs>>): Prisma__RunSlotProjectionClient<$Result.GetResult<Prisma.$RunSlotProjectionPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunSlotProjectionCountArgs>(args?: Subset<T$1, RunSlotProjectionCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends RunSlotProjectionAggregateArgs>(args: Subset<T$1, RunSlotProjectionAggregateArgs>): Prisma.PrismaPromise<GetRunSlotProjectionAggregateType<T$1>>;

    /**
     * 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$1 extends RunSlotProjectionGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: RunSlotProjectionGroupByArgs['orderBy'];
    } : {
      orderBy?: RunSlotProjectionGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, RunSlotProjectionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRunSlotProjectionGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    run<T$1 extends RunDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, RunDefaultArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends TestSuiteRunAggregateArgs> = { [P in keyof T$1 & keyof AggregateTestSuiteRun]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateTestSuiteRun[P]> : GetScalarType<T$1[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$1 extends TestSuiteRunGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<TestSuiteRunGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof TestSuiteRunGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], TestSuiteRunGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | TestSuiteRunDefaultArgs> = $Result.GetResult<Prisma.$TestSuiteRunPayload, S$1>;
  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$1 = {}> {
    [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$1 extends TestSuiteRunFindUniqueArgs>(args: SelectSubset<T$1, TestSuiteRunFindUniqueArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunFindUniqueOrThrowArgs>(args: SelectSubset<T$1, TestSuiteRunFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunFindFirstArgs>(args?: SelectSubset<T$1, TestSuiteRunFindFirstArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunFindFirstOrThrowArgs>(args?: SelectSubset<T$1, TestSuiteRunFindFirstOrThrowArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunFindManyArgs>(args?: SelectSubset<T$1, TestSuiteRunFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TestSuiteRunCreateArgs>(args: SelectSubset<T$1, TestSuiteRunCreateArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends TestSuiteRunCreateManyAndReturnArgs>(args?: SelectSubset<T$1, TestSuiteRunCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TestSuiteRunDeleteArgs>(args: SelectSubset<T$1, TestSuiteRunDeleteArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunUpdateArgs>(args: SelectSubset<T$1, TestSuiteRunUpdateArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends TestSuiteRunUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends TestSuiteRunUpdateManyAndReturnArgs>(args: SelectSubset<T$1, TestSuiteRunUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TestSuiteRunUpsertArgs>(args: SelectSubset<T$1, TestSuiteRunUpsertArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestSuiteRunCountArgs>(args?: Subset<T$1, TestSuiteRunCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends TestSuiteRunAggregateArgs>(args: Subset<T$1, TestSuiteRunAggregateArgs>): Prisma.PrismaPromise<GetTestSuiteRunAggregateType<T$1>>;

    /**
     * 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$1 extends TestSuiteRunGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: TestSuiteRunGroupByArgs['orderBy'];
    } : {
      orderBy?: TestSuiteRunGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, TestSuiteRunGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTestSuiteRunGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    runs<T$1 extends TestSuiteRun$runsArgs<ExtArgs> = {}>(args?: Subset<T$1, TestSuiteRun$runsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | Null>;
    assertions<T$1 extends TestSuiteRun$assertionsArgs<ExtArgs> = {}>(args?: Subset<T$1, TestSuiteRun$assertionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends TestAssertionAggregateArgs> = { [P in keyof T$1 & keyof AggregateTestAssertion]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateTestAssertion[P]> : GetScalarType<T$1[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$1 extends TestAssertionGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<TestAssertionGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof TestAssertionGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], TestAssertionGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | TestAssertionDefaultArgs> = $Result.GetResult<Prisma.$TestAssertionPayload, S$1>;
  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$1 = {}> {
    [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$1 extends TestAssertionFindUniqueArgs>(args: SelectSubset<T$1, TestAssertionFindUniqueArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionFindUniqueOrThrowArgs>(args: SelectSubset<T$1, TestAssertionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionFindFirstArgs>(args?: SelectSubset<T$1, TestAssertionFindFirstArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionFindFirstOrThrowArgs>(args?: SelectSubset<T$1, TestAssertionFindFirstOrThrowArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionFindManyArgs>(args?: SelectSubset<T$1, TestAssertionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TestAssertionCreateArgs>(args: SelectSubset<T$1, TestAssertionCreateArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends TestAssertionCreateManyAndReturnArgs>(args?: SelectSubset<T$1, TestAssertionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TestAssertionDeleteArgs>(args: SelectSubset<T$1, TestAssertionDeleteArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionUpdateArgs>(args: SelectSubset<T$1, TestAssertionUpdateArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends TestAssertionUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends TestAssertionUpdateManyAndReturnArgs>(args: SelectSubset<T$1, TestAssertionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TestAssertionUpsertArgs>(args: SelectSubset<T$1, TestAssertionUpsertArgs<ExtArgs>>): Prisma__TestAssertionClient<$Result.GetResult<Prisma.$TestAssertionPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TestAssertionCountArgs>(args?: Subset<T$1, TestAssertionCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends TestAssertionAggregateArgs>(args: Subset<T$1, TestAssertionAggregateArgs>): Prisma.PrismaPromise<GetTestAssertionAggregateType<T$1>>;

    /**
     * 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$1 extends TestAssertionGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: TestAssertionGroupByArgs['orderBy'];
    } : {
      orderBy?: TestAssertionGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, TestAssertionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTestAssertionGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    run<T$1 extends RunDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, RunDefaultArgs<ExtArgs>>): Prisma__RunClient<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    testSuiteRun<T$1 extends TestSuiteRunDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, TestSuiteRunDefaultArgs<ExtArgs>>): Prisma__TestSuiteRunClient<$Result.GetResult<Prisma.$TestSuiteRunPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends WorkflowDebuggerOverlayAggregateArgs> = { [P in keyof T$1 & keyof AggregateWorkflowDebuggerOverlay]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateWorkflowDebuggerOverlay[P]> : GetScalarType<T$1[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$1 extends WorkflowDebuggerOverlayGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<WorkflowDebuggerOverlayGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof WorkflowDebuggerOverlayGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], WorkflowDebuggerOverlayGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | WorkflowDebuggerOverlayDefaultArgs> = $Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload, S$1>;
  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$1 = {}> {
    [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$1 extends WorkflowDebuggerOverlayFindUniqueArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayFindUniqueArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayFindUniqueOrThrowArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayFindUniqueOrThrowArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayFindFirstArgs>(args?: SelectSubset<T$1, WorkflowDebuggerOverlayFindFirstArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayFindFirstOrThrowArgs>(args?: SelectSubset<T$1, WorkflowDebuggerOverlayFindFirstOrThrowArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayFindManyArgs>(args?: SelectSubset<T$1, WorkflowDebuggerOverlayFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayCreateArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayCreateArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowDebuggerOverlayCreateManyAndReturnArgs>(args?: SelectSubset<T$1, WorkflowDebuggerOverlayCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayDeleteArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayDeleteArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayUpdateArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayUpdateArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowDebuggerOverlayUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends WorkflowDebuggerOverlayUpdateManyAndReturnArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayUpsertArgs>(args: SelectSubset<T$1, WorkflowDebuggerOverlayUpsertArgs<ExtArgs>>): Prisma__WorkflowDebuggerOverlayClient<$Result.GetResult<Prisma.$WorkflowDebuggerOverlayPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayCountArgs>(args?: Subset<T$1, WorkflowDebuggerOverlayCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends WorkflowDebuggerOverlayAggregateArgs>(args: Subset<T$1, WorkflowDebuggerOverlayAggregateArgs>): Prisma.PrismaPromise<GetWorkflowDebuggerOverlayAggregateType<T$1>>;

    /**
     * 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$1 extends WorkflowDebuggerOverlayGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: WorkflowDebuggerOverlayGroupByArgs['orderBy'];
    } : {
      orderBy?: WorkflowDebuggerOverlayGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, WorkflowDebuggerOverlayGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWorkflowDebuggerOverlayGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends WorkflowActivationAggregateArgs> = { [P in keyof T$1 & keyof AggregateWorkflowActivation]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateWorkflowActivation[P]> : GetScalarType<T$1[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$1 extends WorkflowActivationGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<WorkflowActivationGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof WorkflowActivationGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], WorkflowActivationGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | WorkflowActivationDefaultArgs> = $Result.GetResult<Prisma.$WorkflowActivationPayload, S$1>;
  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$1 = {}> {
    [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$1 extends WorkflowActivationFindUniqueArgs>(args: SelectSubset<T$1, WorkflowActivationFindUniqueArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationFindUniqueOrThrowArgs>(args: SelectSubset<T$1, WorkflowActivationFindUniqueOrThrowArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationFindFirstArgs>(args?: SelectSubset<T$1, WorkflowActivationFindFirstArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationFindFirstOrThrowArgs>(args?: SelectSubset<T$1, WorkflowActivationFindFirstOrThrowArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationFindManyArgs>(args?: SelectSubset<T$1, WorkflowActivationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowActivationCreateArgs>(args: SelectSubset<T$1, WorkflowActivationCreateArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowActivationCreateManyAndReturnArgs>(args?: SelectSubset<T$1, WorkflowActivationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowActivationDeleteArgs>(args: SelectSubset<T$1, WorkflowActivationDeleteArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationUpdateArgs>(args: SelectSubset<T$1, WorkflowActivationUpdateArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowActivationUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends WorkflowActivationUpdateManyAndReturnArgs>(args: SelectSubset<T$1, WorkflowActivationUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowActivationUpsertArgs>(args: SelectSubset<T$1, WorkflowActivationUpsertArgs<ExtArgs>>): Prisma__WorkflowActivationClient<$Result.GetResult<Prisma.$WorkflowActivationPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowActivationCountArgs>(args?: Subset<T$1, WorkflowActivationCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends WorkflowActivationAggregateArgs>(args: Subset<T$1, WorkflowActivationAggregateArgs>): Prisma.PrismaPromise<GetWorkflowActivationAggregateType<T$1>>;

    /**
     * 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$1 extends WorkflowActivationGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: WorkflowActivationGroupByArgs['orderBy'];
    } : {
      orderBy?: WorkflowActivationGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, WorkflowActivationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWorkflowActivationGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends TriggerSetupStateAggregateArgs> = { [P in keyof T$1 & keyof AggregateTriggerSetupState]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateTriggerSetupState[P]> : GetScalarType<T$1[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$1 extends TriggerSetupStateGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<TriggerSetupStateGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof TriggerSetupStateGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], TriggerSetupStateGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | TriggerSetupStateDefaultArgs> = $Result.GetResult<Prisma.$TriggerSetupStatePayload, S$1>;
  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$1 = {}> {
    [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$1 extends TriggerSetupStateFindUniqueArgs>(args: SelectSubset<T$1, TriggerSetupStateFindUniqueArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateFindUniqueOrThrowArgs>(args: SelectSubset<T$1, TriggerSetupStateFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateFindFirstArgs>(args?: SelectSubset<T$1, TriggerSetupStateFindFirstArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateFindFirstOrThrowArgs>(args?: SelectSubset<T$1, TriggerSetupStateFindFirstOrThrowArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateFindManyArgs>(args?: SelectSubset<T$1, TriggerSetupStateFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TriggerSetupStateCreateArgs>(args: SelectSubset<T$1, TriggerSetupStateCreateArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends TriggerSetupStateCreateManyAndReturnArgs>(args?: SelectSubset<T$1, TriggerSetupStateCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TriggerSetupStateDeleteArgs>(args: SelectSubset<T$1, TriggerSetupStateDeleteArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateUpdateArgs>(args: SelectSubset<T$1, TriggerSetupStateUpdateArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends TriggerSetupStateUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends TriggerSetupStateUpdateManyAndReturnArgs>(args: SelectSubset<T$1, TriggerSetupStateUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TriggerSetupStateUpsertArgs>(args: SelectSubset<T$1, TriggerSetupStateUpsertArgs<ExtArgs>>): Prisma__TriggerSetupStateClient<$Result.GetResult<Prisma.$TriggerSetupStatePayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TriggerSetupStateCountArgs>(args?: Subset<T$1, TriggerSetupStateCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends TriggerSetupStateAggregateArgs>(args: Subset<T$1, TriggerSetupStateAggregateArgs>): Prisma.PrismaPromise<GetTriggerSetupStateAggregateType<T$1>>;

    /**
     * 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$1 extends TriggerSetupStateGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: TriggerSetupStateGroupByArgs['orderBy'];
    } : {
      orderBy?: TriggerSetupStateGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, TriggerSetupStateGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTriggerSetupStateGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends RunTraceContextAggregateArgs> = { [P in keyof T$1 & keyof AggregateRunTraceContext]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateRunTraceContext[P]> : GetScalarType<T$1[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$1 extends RunTraceContextGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<RunTraceContextGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof RunTraceContextGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], RunTraceContextGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | RunTraceContextDefaultArgs> = $Result.GetResult<Prisma.$RunTraceContextPayload, S$1>;
  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$1 = {}> {
    [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$1 extends RunTraceContextFindUniqueArgs>(args: SelectSubset<T$1, RunTraceContextFindUniqueArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextFindUniqueOrThrowArgs>(args: SelectSubset<T$1, RunTraceContextFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextFindFirstArgs>(args?: SelectSubset<T$1, RunTraceContextFindFirstArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextFindFirstOrThrowArgs>(args?: SelectSubset<T$1, RunTraceContextFindFirstOrThrowArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextFindManyArgs>(args?: SelectSubset<T$1, RunTraceContextFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunTraceContextCreateArgs>(args: SelectSubset<T$1, RunTraceContextCreateArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunTraceContextCreateManyAndReturnArgs>(args?: SelectSubset<T$1, RunTraceContextCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunTraceContextDeleteArgs>(args: SelectSubset<T$1, RunTraceContextDeleteArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextUpdateArgs>(args: SelectSubset<T$1, RunTraceContextUpdateArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends RunTraceContextUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends RunTraceContextUpdateManyAndReturnArgs>(args: SelectSubset<T$1, RunTraceContextUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends RunTraceContextUpsertArgs>(args: SelectSubset<T$1, RunTraceContextUpsertArgs<ExtArgs>>): Prisma__RunTraceContextClient<$Result.GetResult<Prisma.$RunTraceContextPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends RunTraceContextCountArgs>(args?: Subset<T$1, RunTraceContextCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends RunTraceContextAggregateArgs>(args: Subset<T$1, RunTraceContextAggregateArgs>): Prisma.PrismaPromise<GetRunTraceContextAggregateType<T$1>>;

    /**
     * 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$1 extends RunTraceContextGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: RunTraceContextGroupByArgs['orderBy'];
    } : {
      orderBy?: RunTraceContextGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, RunTraceContextGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRunTraceContextGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends TelemetrySpanAggregateArgs> = { [P in keyof T$1 & keyof AggregateTelemetrySpan]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateTelemetrySpan[P]> : GetScalarType<T$1[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$1 extends TelemetrySpanGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<TelemetrySpanGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof TelemetrySpanGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], TelemetrySpanGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | TelemetrySpanDefaultArgs> = $Result.GetResult<Prisma.$TelemetrySpanPayload, S$1>;
  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$1 = {}> {
    [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$1 extends TelemetrySpanFindUniqueArgs>(args: SelectSubset<T$1, TelemetrySpanFindUniqueArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanFindUniqueOrThrowArgs>(args: SelectSubset<T$1, TelemetrySpanFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanFindFirstArgs>(args?: SelectSubset<T$1, TelemetrySpanFindFirstArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanFindFirstOrThrowArgs>(args?: SelectSubset<T$1, TelemetrySpanFindFirstOrThrowArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanFindManyArgs>(args?: SelectSubset<T$1, TelemetrySpanFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetrySpanCreateArgs>(args: SelectSubset<T$1, TelemetrySpanCreateArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends TelemetrySpanCreateManyAndReturnArgs>(args?: SelectSubset<T$1, TelemetrySpanCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetrySpanDeleteArgs>(args: SelectSubset<T$1, TelemetrySpanDeleteArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanUpdateArgs>(args: SelectSubset<T$1, TelemetrySpanUpdateArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends TelemetrySpanUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends TelemetrySpanUpdateManyAndReturnArgs>(args: SelectSubset<T$1, TelemetrySpanUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetrySpanUpsertArgs>(args: SelectSubset<T$1, TelemetrySpanUpsertArgs<ExtArgs>>): Prisma__TelemetrySpanClient<$Result.GetResult<Prisma.$TelemetrySpanPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetrySpanCountArgs>(args?: Subset<T$1, TelemetrySpanCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends TelemetrySpanAggregateArgs>(args: Subset<T$1, TelemetrySpanAggregateArgs>): Prisma.PrismaPromise<GetTelemetrySpanAggregateType<T$1>>;

    /**
     * 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$1 extends TelemetrySpanGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: TelemetrySpanGroupByArgs['orderBy'];
    } : {
      orderBy?: TelemetrySpanGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, TelemetrySpanGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTelemetrySpanGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends WorkflowSnapshotAggregateArgs> = { [P in keyof T$1 & keyof AggregateWorkflowSnapshot]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateWorkflowSnapshot[P]> : GetScalarType<T$1[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$1 extends WorkflowSnapshotGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<WorkflowSnapshotGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof WorkflowSnapshotGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], WorkflowSnapshotGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | WorkflowSnapshotDefaultArgs> = $Result.GetResult<Prisma.$WorkflowSnapshotPayload, S$1>;
  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$1 = {}> {
    [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$1 extends WorkflowSnapshotFindUniqueArgs>(args: SelectSubset<T$1, WorkflowSnapshotFindUniqueArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotFindUniqueOrThrowArgs>(args: SelectSubset<T$1, WorkflowSnapshotFindUniqueOrThrowArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotFindFirstArgs>(args?: SelectSubset<T$1, WorkflowSnapshotFindFirstArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotFindFirstOrThrowArgs>(args?: SelectSubset<T$1, WorkflowSnapshotFindFirstOrThrowArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotFindManyArgs>(args?: SelectSubset<T$1, WorkflowSnapshotFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowSnapshotCreateArgs>(args: SelectSubset<T$1, WorkflowSnapshotCreateArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowSnapshotCreateManyAndReturnArgs>(args?: SelectSubset<T$1, WorkflowSnapshotCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowSnapshotDeleteArgs>(args: SelectSubset<T$1, WorkflowSnapshotDeleteArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotUpdateArgs>(args: SelectSubset<T$1, WorkflowSnapshotUpdateArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowSnapshotUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends WorkflowSnapshotUpdateManyAndReturnArgs>(args: SelectSubset<T$1, WorkflowSnapshotUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowSnapshotUpsertArgs>(args: SelectSubset<T$1, WorkflowSnapshotUpsertArgs<ExtArgs>>): Prisma__WorkflowSnapshotClient<$Result.GetResult<Prisma.$WorkflowSnapshotPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowSnapshotCountArgs>(args?: Subset<T$1, WorkflowSnapshotCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends WorkflowSnapshotAggregateArgs>(args: Subset<T$1, WorkflowSnapshotAggregateArgs>): Prisma.PrismaPromise<GetWorkflowSnapshotAggregateType<T$1>>;

    /**
     * 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$1 extends WorkflowSnapshotGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: WorkflowSnapshotGroupByArgs['orderBy'];
    } : {
      orderBy?: WorkflowSnapshotGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, WorkflowSnapshotGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWorkflowSnapshotGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    runs<T$1 extends WorkflowSnapshot$runsArgs<ExtArgs> = {}>(args?: Subset<T$1, WorkflowSnapshot$runsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RunPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends TelemetryArtifactAggregateArgs> = { [P in keyof T$1 & keyof AggregateTelemetryArtifact]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateTelemetryArtifact[P]> : GetScalarType<T$1[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$1 extends TelemetryArtifactGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<TelemetryArtifactGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof TelemetryArtifactGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], TelemetryArtifactGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | TelemetryArtifactDefaultArgs> = $Result.GetResult<Prisma.$TelemetryArtifactPayload, S$1>;
  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$1 = {}> {
    [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$1 extends TelemetryArtifactFindUniqueArgs>(args: SelectSubset<T$1, TelemetryArtifactFindUniqueArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactFindUniqueOrThrowArgs>(args: SelectSubset<T$1, TelemetryArtifactFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactFindFirstArgs>(args?: SelectSubset<T$1, TelemetryArtifactFindFirstArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactFindFirstOrThrowArgs>(args?: SelectSubset<T$1, TelemetryArtifactFindFirstOrThrowArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactFindManyArgs>(args?: SelectSubset<T$1, TelemetryArtifactFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetryArtifactCreateArgs>(args: SelectSubset<T$1, TelemetryArtifactCreateArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends TelemetryArtifactCreateManyAndReturnArgs>(args?: SelectSubset<T$1, TelemetryArtifactCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetryArtifactDeleteArgs>(args: SelectSubset<T$1, TelemetryArtifactDeleteArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactUpdateArgs>(args: SelectSubset<T$1, TelemetryArtifactUpdateArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends TelemetryArtifactUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends TelemetryArtifactUpdateManyAndReturnArgs>(args: SelectSubset<T$1, TelemetryArtifactUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetryArtifactUpsertArgs>(args: SelectSubset<T$1, TelemetryArtifactUpsertArgs<ExtArgs>>): Prisma__TelemetryArtifactClient<$Result.GetResult<Prisma.$TelemetryArtifactPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryArtifactCountArgs>(args?: Subset<T$1, TelemetryArtifactCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends TelemetryArtifactAggregateArgs>(args: Subset<T$1, TelemetryArtifactAggregateArgs>): Prisma.PrismaPromise<GetTelemetryArtifactAggregateType<T$1>>;

    /**
     * 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$1 extends TelemetryArtifactGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: TelemetryArtifactGroupByArgs['orderBy'];
    } : {
      orderBy?: TelemetryArtifactGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, TelemetryArtifactGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTelemetryArtifactGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends TelemetryMetricPointAggregateArgs> = { [P in keyof T$1 & keyof AggregateTelemetryMetricPoint]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateTelemetryMetricPoint[P]> : GetScalarType<T$1[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$1 extends TelemetryMetricPointGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<TelemetryMetricPointGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof TelemetryMetricPointGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], TelemetryMetricPointGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | TelemetryMetricPointDefaultArgs> = $Result.GetResult<Prisma.$TelemetryMetricPointPayload, S$1>;
  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$1 = {}> {
    [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$1 extends TelemetryMetricPointFindUniqueArgs>(args: SelectSubset<T$1, TelemetryMetricPointFindUniqueArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointFindUniqueOrThrowArgs>(args: SelectSubset<T$1, TelemetryMetricPointFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointFindFirstArgs>(args?: SelectSubset<T$1, TelemetryMetricPointFindFirstArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointFindFirstOrThrowArgs>(args?: SelectSubset<T$1, TelemetryMetricPointFindFirstOrThrowArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointFindManyArgs>(args?: SelectSubset<T$1, TelemetryMetricPointFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetryMetricPointCreateArgs>(args: SelectSubset<T$1, TelemetryMetricPointCreateArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends TelemetryMetricPointCreateManyAndReturnArgs>(args?: SelectSubset<T$1, TelemetryMetricPointCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetryMetricPointDeleteArgs>(args: SelectSubset<T$1, TelemetryMetricPointDeleteArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointUpdateArgs>(args: SelectSubset<T$1, TelemetryMetricPointUpdateArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends TelemetryMetricPointUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends TelemetryMetricPointUpdateManyAndReturnArgs>(args: SelectSubset<T$1, TelemetryMetricPointUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends TelemetryMetricPointUpsertArgs>(args: SelectSubset<T$1, TelemetryMetricPointUpsertArgs<ExtArgs>>): Prisma__TelemetryMetricPointClient<$Result.GetResult<Prisma.$TelemetryMetricPointPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends TelemetryMetricPointCountArgs>(args?: Subset<T$1, TelemetryMetricPointCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends TelemetryMetricPointAggregateArgs>(args: Subset<T$1, TelemetryMetricPointAggregateArgs>): Prisma.PrismaPromise<GetTelemetryMetricPointAggregateType<T$1>>;

    /**
     * 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$1 extends TelemetryMetricPointGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: TelemetryMetricPointGroupByArgs['orderBy'];
    } : {
      orderBy?: TelemetryMetricPointGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, TelemetryMetricPointGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTelemetryMetricPointGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends CredentialInstanceAggregateArgs> = { [P in keyof T$1 & keyof AggregateCredentialInstance]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateCredentialInstance[P]> : GetScalarType<T$1[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$1 extends CredentialInstanceGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<CredentialInstanceGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof CredentialInstanceGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], CredentialInstanceGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | CredentialInstanceDefaultArgs> = $Result.GetResult<Prisma.$CredentialInstancePayload, S$1>;
  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$1 = {}> {
    [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$1 extends CredentialInstanceFindUniqueArgs>(args: SelectSubset<T$1, CredentialInstanceFindUniqueArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceFindUniqueOrThrowArgs>(args: SelectSubset<T$1, CredentialInstanceFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceFindFirstArgs>(args?: SelectSubset<T$1, CredentialInstanceFindFirstArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceFindFirstOrThrowArgs>(args?: SelectSubset<T$1, CredentialInstanceFindFirstOrThrowArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceFindManyArgs>(args?: SelectSubset<T$1, CredentialInstanceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialInstanceCreateArgs>(args: SelectSubset<T$1, CredentialInstanceCreateArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialInstanceCreateManyAndReturnArgs>(args?: SelectSubset<T$1, CredentialInstanceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialInstanceDeleteArgs>(args: SelectSubset<T$1, CredentialInstanceDeleteArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceUpdateArgs>(args: SelectSubset<T$1, CredentialInstanceUpdateArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialInstanceUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends CredentialInstanceUpdateManyAndReturnArgs>(args: SelectSubset<T$1, CredentialInstanceUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialInstanceUpsertArgs>(args: SelectSubset<T$1, CredentialInstanceUpsertArgs<ExtArgs>>): Prisma__CredentialInstanceClient<$Result.GetResult<Prisma.$CredentialInstancePayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialInstanceCountArgs>(args?: Subset<T$1, CredentialInstanceCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends CredentialInstanceAggregateArgs>(args: Subset<T$1, CredentialInstanceAggregateArgs>): Prisma.PrismaPromise<GetCredentialInstanceAggregateType<T$1>>;

    /**
     * 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$1 extends CredentialInstanceGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: CredentialInstanceGroupByArgs['orderBy'];
    } : {
      orderBy?: CredentialInstanceGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, CredentialInstanceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCredentialInstanceGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends CredentialSecretMaterialAggregateArgs> = { [P in keyof T$1 & keyof AggregateCredentialSecretMaterial]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateCredentialSecretMaterial[P]> : GetScalarType<T$1[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$1 extends CredentialSecretMaterialGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<CredentialSecretMaterialGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof CredentialSecretMaterialGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], CredentialSecretMaterialGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | CredentialSecretMaterialDefaultArgs> = $Result.GetResult<Prisma.$CredentialSecretMaterialPayload, S$1>;
  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$1 = {}> {
    [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$1 extends CredentialSecretMaterialFindUniqueArgs>(args: SelectSubset<T$1, CredentialSecretMaterialFindUniqueArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialFindUniqueOrThrowArgs>(args: SelectSubset<T$1, CredentialSecretMaterialFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialFindFirstArgs>(args?: SelectSubset<T$1, CredentialSecretMaterialFindFirstArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialFindFirstOrThrowArgs>(args?: SelectSubset<T$1, CredentialSecretMaterialFindFirstOrThrowArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialFindManyArgs>(args?: SelectSubset<T$1, CredentialSecretMaterialFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialSecretMaterialCreateArgs>(args: SelectSubset<T$1, CredentialSecretMaterialCreateArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialSecretMaterialCreateManyAndReturnArgs>(args?: SelectSubset<T$1, CredentialSecretMaterialCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialSecretMaterialDeleteArgs>(args: SelectSubset<T$1, CredentialSecretMaterialDeleteArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialUpdateArgs>(args: SelectSubset<T$1, CredentialSecretMaterialUpdateArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialSecretMaterialUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends CredentialSecretMaterialUpdateManyAndReturnArgs>(args: SelectSubset<T$1, CredentialSecretMaterialUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialSecretMaterialUpsertArgs>(args: SelectSubset<T$1, CredentialSecretMaterialUpsertArgs<ExtArgs>>): Prisma__CredentialSecretMaterialClient<$Result.GetResult<Prisma.$CredentialSecretMaterialPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialSecretMaterialCountArgs>(args?: Subset<T$1, CredentialSecretMaterialCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends CredentialSecretMaterialAggregateArgs>(args: Subset<T$1, CredentialSecretMaterialAggregateArgs>): Prisma.PrismaPromise<GetCredentialSecretMaterialAggregateType<T$1>>;

    /**
     * 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$1 extends CredentialSecretMaterialGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: CredentialSecretMaterialGroupByArgs['orderBy'];
    } : {
      orderBy?: CredentialSecretMaterialGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, CredentialSecretMaterialGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCredentialSecretMaterialGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends CredentialOAuth2MaterialAggregateArgs> = { [P in keyof T$1 & keyof AggregateCredentialOAuth2Material]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateCredentialOAuth2Material[P]> : GetScalarType<T$1[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$1 extends CredentialOAuth2MaterialGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<CredentialOAuth2MaterialGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof CredentialOAuth2MaterialGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], CredentialOAuth2MaterialGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | CredentialOAuth2MaterialDefaultArgs> = $Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload, S$1>;
  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$1 = {}> {
    [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$1 extends CredentialOAuth2MaterialFindUniqueArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialFindUniqueArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialFindUniqueOrThrowArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialFindFirstArgs>(args?: SelectSubset<T$1, CredentialOAuth2MaterialFindFirstArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialFindFirstOrThrowArgs>(args?: SelectSubset<T$1, CredentialOAuth2MaterialFindFirstOrThrowArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialFindManyArgs>(args?: SelectSubset<T$1, CredentialOAuth2MaterialFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialOAuth2MaterialCreateArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialCreateArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialOAuth2MaterialCreateManyAndReturnArgs>(args?: SelectSubset<T$1, CredentialOAuth2MaterialCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialOAuth2MaterialDeleteArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialDeleteArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialUpdateArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialUpdateArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialOAuth2MaterialUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends CredentialOAuth2MaterialUpdateManyAndReturnArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialOAuth2MaterialUpsertArgs>(args: SelectSubset<T$1, CredentialOAuth2MaterialUpsertArgs<ExtArgs>>): Prisma__CredentialOAuth2MaterialClient<$Result.GetResult<Prisma.$CredentialOAuth2MaterialPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2MaterialCountArgs>(args?: Subset<T$1, CredentialOAuth2MaterialCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends CredentialOAuth2MaterialAggregateArgs>(args: Subset<T$1, CredentialOAuth2MaterialAggregateArgs>): Prisma.PrismaPromise<GetCredentialOAuth2MaterialAggregateType<T$1>>;

    /**
     * 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$1 extends CredentialOAuth2MaterialGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: CredentialOAuth2MaterialGroupByArgs['orderBy'];
    } : {
      orderBy?: CredentialOAuth2MaterialGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, CredentialOAuth2MaterialGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCredentialOAuth2MaterialGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends CredentialOAuth2StateAggregateArgs> = { [P in keyof T$1 & keyof AggregateCredentialOAuth2State]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateCredentialOAuth2State[P]> : GetScalarType<T$1[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$1 extends CredentialOAuth2StateGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<CredentialOAuth2StateGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof CredentialOAuth2StateGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], CredentialOAuth2StateGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | CredentialOAuth2StateDefaultArgs> = $Result.GetResult<Prisma.$CredentialOAuth2StatePayload, S$1>;
  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$1 = {}> {
    [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$1 extends CredentialOAuth2StateFindUniqueArgs>(args: SelectSubset<T$1, CredentialOAuth2StateFindUniqueArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateFindUniqueOrThrowArgs>(args: SelectSubset<T$1, CredentialOAuth2StateFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateFindFirstArgs>(args?: SelectSubset<T$1, CredentialOAuth2StateFindFirstArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateFindFirstOrThrowArgs>(args?: SelectSubset<T$1, CredentialOAuth2StateFindFirstOrThrowArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateFindManyArgs>(args?: SelectSubset<T$1, CredentialOAuth2StateFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialOAuth2StateCreateArgs>(args: SelectSubset<T$1, CredentialOAuth2StateCreateArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialOAuth2StateCreateManyAndReturnArgs>(args?: SelectSubset<T$1, CredentialOAuth2StateCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialOAuth2StateDeleteArgs>(args: SelectSubset<T$1, CredentialOAuth2StateDeleteArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateUpdateArgs>(args: SelectSubset<T$1, CredentialOAuth2StateUpdateArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialOAuth2StateUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends CredentialOAuth2StateUpdateManyAndReturnArgs>(args: SelectSubset<T$1, CredentialOAuth2StateUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialOAuth2StateUpsertArgs>(args: SelectSubset<T$1, CredentialOAuth2StateUpsertArgs<ExtArgs>>): Prisma__CredentialOAuth2StateClient<$Result.GetResult<Prisma.$CredentialOAuth2StatePayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialOAuth2StateCountArgs>(args?: Subset<T$1, CredentialOAuth2StateCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends CredentialOAuth2StateAggregateArgs>(args: Subset<T$1, CredentialOAuth2StateAggregateArgs>): Prisma.PrismaPromise<GetCredentialOAuth2StateAggregateType<T$1>>;

    /**
     * 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$1 extends CredentialOAuth2StateGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: CredentialOAuth2StateGroupByArgs['orderBy'];
    } : {
      orderBy?: CredentialOAuth2StateGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, CredentialOAuth2StateGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCredentialOAuth2StateGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends CredentialBindingAggregateArgs> = { [P in keyof T$1 & keyof AggregateCredentialBinding]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateCredentialBinding[P]> : GetScalarType<T$1[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$1 extends CredentialBindingGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<CredentialBindingGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof CredentialBindingGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], CredentialBindingGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | CredentialBindingDefaultArgs> = $Result.GetResult<Prisma.$CredentialBindingPayload, S$1>;
  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$1 = {}> {
    [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$1 extends CredentialBindingFindUniqueArgs>(args: SelectSubset<T$1, CredentialBindingFindUniqueArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingFindUniqueOrThrowArgs>(args: SelectSubset<T$1, CredentialBindingFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingFindFirstArgs>(args?: SelectSubset<T$1, CredentialBindingFindFirstArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingFindFirstOrThrowArgs>(args?: SelectSubset<T$1, CredentialBindingFindFirstOrThrowArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingFindManyArgs>(args?: SelectSubset<T$1, CredentialBindingFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialBindingCreateArgs>(args: SelectSubset<T$1, CredentialBindingCreateArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialBindingCreateManyAndReturnArgs>(args?: SelectSubset<T$1, CredentialBindingCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialBindingDeleteArgs>(args: SelectSubset<T$1, CredentialBindingDeleteArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingUpdateArgs>(args: SelectSubset<T$1, CredentialBindingUpdateArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialBindingUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends CredentialBindingUpdateManyAndReturnArgs>(args: SelectSubset<T$1, CredentialBindingUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialBindingUpsertArgs>(args: SelectSubset<T$1, CredentialBindingUpsertArgs<ExtArgs>>): Prisma__CredentialBindingClient<$Result.GetResult<Prisma.$CredentialBindingPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialBindingCountArgs>(args?: Subset<T$1, CredentialBindingCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends CredentialBindingAggregateArgs>(args: Subset<T$1, CredentialBindingAggregateArgs>): Prisma.PrismaPromise<GetCredentialBindingAggregateType<T$1>>;

    /**
     * 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$1 extends CredentialBindingGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: CredentialBindingGroupByArgs['orderBy'];
    } : {
      orderBy?: CredentialBindingGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, CredentialBindingGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCredentialBindingGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends CredentialTestResultAggregateArgs> = { [P in keyof T$1 & keyof AggregateCredentialTestResult]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateCredentialTestResult[P]> : GetScalarType<T$1[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$1 extends CredentialTestResultGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<CredentialTestResultGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof CredentialTestResultGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], CredentialTestResultGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | CredentialTestResultDefaultArgs> = $Result.GetResult<Prisma.$CredentialTestResultPayload, S$1>;
  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$1 = {}> {
    [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$1 extends CredentialTestResultFindUniqueArgs>(args: SelectSubset<T$1, CredentialTestResultFindUniqueArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultFindUniqueOrThrowArgs>(args: SelectSubset<T$1, CredentialTestResultFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultFindFirstArgs>(args?: SelectSubset<T$1, CredentialTestResultFindFirstArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultFindFirstOrThrowArgs>(args?: SelectSubset<T$1, CredentialTestResultFindFirstOrThrowArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultFindManyArgs>(args?: SelectSubset<T$1, CredentialTestResultFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialTestResultCreateArgs>(args: SelectSubset<T$1, CredentialTestResultCreateArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialTestResultCreateManyAndReturnArgs>(args?: SelectSubset<T$1, CredentialTestResultCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialTestResultDeleteArgs>(args: SelectSubset<T$1, CredentialTestResultDeleteArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultUpdateArgs>(args: SelectSubset<T$1, CredentialTestResultUpdateArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends CredentialTestResultUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends CredentialTestResultUpdateManyAndReturnArgs>(args: SelectSubset<T$1, CredentialTestResultUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends CredentialTestResultUpsertArgs>(args: SelectSubset<T$1, CredentialTestResultUpsertArgs<ExtArgs>>): Prisma__CredentialTestResultClient<$Result.GetResult<Prisma.$CredentialTestResultPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends CredentialTestResultCountArgs>(args?: Subset<T$1, CredentialTestResultCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends CredentialTestResultAggregateArgs>(args: Subset<T$1, CredentialTestResultAggregateArgs>): Prisma.PrismaPromise<GetCredentialTestResultAggregateType<T$1>>;

    /**
     * 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$1 extends CredentialTestResultGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: CredentialTestResultGroupByArgs['orderBy'];
    } : {
      orderBy?: CredentialTestResultGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, CredentialTestResultGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCredentialTestResultGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends UserAggregateArgs> = { [P in keyof T$1 & keyof AggregateUser]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateUser[P]> : GetScalarType<T$1[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$1 extends UserGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<UserGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof UserGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], UserGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S$1>;
  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$1 = {}> {
    [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$1 extends UserFindUniqueArgs>(args: SelectSubset<T$1, UserFindUniqueArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserFindUniqueOrThrowArgs>(args: SelectSubset<T$1, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserFindFirstArgs>(args?: SelectSubset<T$1, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T$1, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserFindManyArgs>(args?: SelectSubset<T$1, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends UserCreateArgs>(args: SelectSubset<T$1, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends UserCreateManyAndReturnArgs>(args?: SelectSubset<T$1, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends UserDeleteArgs>(args: SelectSubset<T$1, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserUpdateArgs>(args: SelectSubset<T$1, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends UserUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends UserUpdateManyAndReturnArgs>(args: SelectSubset<T$1, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends UserUpsertArgs>(args: SelectSubset<T$1, UserUpsertArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserCountArgs>(args?: Subset<T$1, UserCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends UserAggregateArgs>(args: Subset<T$1, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T$1>>;

    /**
     * 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$1 extends UserGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: UserGroupByArgs['orderBy'];
    } : {
      orderBy?: UserGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    accounts<T$1 extends User$accountsArgs<ExtArgs> = {}>(args?: Subset<T$1, User$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | Null>;
    sessions<T$1 extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T$1, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | Null>;
    invites<T$1 extends User$invitesArgs<ExtArgs> = {}>(args?: Subset<T$1, User$invitesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1> | 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends UserInviteAggregateArgs> = { [P in keyof T$1 & keyof AggregateUserInvite]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateUserInvite[P]> : GetScalarType<T$1[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$1 extends UserInviteGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<UserInviteGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof UserInviteGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], UserInviteGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | UserInviteDefaultArgs> = $Result.GetResult<Prisma.$UserInvitePayload, S$1>;
  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$1 = {}> {
    [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$1 extends UserInviteFindUniqueArgs>(args: SelectSubset<T$1, UserInviteFindUniqueArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteFindUniqueOrThrowArgs>(args: SelectSubset<T$1, UserInviteFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteFindFirstArgs>(args?: SelectSubset<T$1, UserInviteFindFirstArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteFindFirstOrThrowArgs>(args?: SelectSubset<T$1, UserInviteFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteFindManyArgs>(args?: SelectSubset<T$1, UserInviteFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends UserInviteCreateArgs>(args: SelectSubset<T$1, UserInviteCreateArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends UserInviteCreateManyAndReturnArgs>(args?: SelectSubset<T$1, UserInviteCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends UserInviteDeleteArgs>(args: SelectSubset<T$1, UserInviteDeleteArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteUpdateArgs>(args: SelectSubset<T$1, UserInviteUpdateArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends UserInviteUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends UserInviteUpdateManyAndReturnArgs>(args: SelectSubset<T$1, UserInviteUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends UserInviteUpsertArgs>(args: SelectSubset<T$1, UserInviteUpsertArgs<ExtArgs>>): Prisma__UserInviteClient<$Result.GetResult<Prisma.$UserInvitePayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends UserInviteCountArgs>(args?: Subset<T$1, UserInviteCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends UserInviteAggregateArgs>(args: Subset<T$1, UserInviteAggregateArgs>): Prisma.PrismaPromise<GetUserInviteAggregateType<T$1>>;

    /**
     * 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$1 extends UserInviteGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: UserInviteGroupByArgs['orderBy'];
    } : {
      orderBy?: UserInviteGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, UserInviteGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserInviteGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    user<T$1 extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends AccountAggregateArgs> = { [P in keyof T$1 & keyof AggregateAccount]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateAccount[P]> : GetScalarType<T$1[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$1 extends AccountGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<AccountGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof AccountGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], AccountGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | AccountDefaultArgs> = $Result.GetResult<Prisma.$AccountPayload, S$1>;
  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$1 = {}> {
    [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$1 extends AccountFindUniqueArgs>(args: SelectSubset<T$1, AccountFindUniqueArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountFindUniqueOrThrowArgs>(args: SelectSubset<T$1, AccountFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountFindFirstArgs>(args?: SelectSubset<T$1, AccountFindFirstArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountFindFirstOrThrowArgs>(args?: SelectSubset<T$1, AccountFindFirstOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountFindManyArgs>(args?: SelectSubset<T$1, AccountFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends AccountCreateArgs>(args: SelectSubset<T$1, AccountCreateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends AccountCreateManyAndReturnArgs>(args?: SelectSubset<T$1, AccountCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends AccountDeleteArgs>(args: SelectSubset<T$1, AccountDeleteArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountUpdateArgs>(args: SelectSubset<T$1, AccountUpdateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends AccountUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends AccountUpdateManyAndReturnArgs>(args: SelectSubset<T$1, AccountUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends AccountUpsertArgs>(args: SelectSubset<T$1, AccountUpsertArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends AccountCountArgs>(args?: Subset<T$1, AccountCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends AccountAggregateArgs>(args: Subset<T$1, AccountAggregateArgs>): Prisma.PrismaPromise<GetAccountAggregateType<T$1>>;

    /**
     * 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$1 extends AccountGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: AccountGroupByArgs['orderBy'];
    } : {
      orderBy?: AccountGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, AccountGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccountGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    user<T$1 extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends SessionAggregateArgs> = { [P in keyof T$1 & keyof AggregateSession]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateSession[P]> : GetScalarType<T$1[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$1 extends SessionGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<SessionGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof SessionGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], SessionGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | SessionDefaultArgs> = $Result.GetResult<Prisma.$SessionPayload, S$1>;
  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$1 = {}> {
    [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$1 extends SessionFindUniqueArgs>(args: SelectSubset<T$1, SessionFindUniqueArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionFindUniqueOrThrowArgs>(args: SelectSubset<T$1, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionFindFirstArgs>(args?: SelectSubset<T$1, SessionFindFirstArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionFindFirstOrThrowArgs>(args?: SelectSubset<T$1, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionFindManyArgs>(args?: SelectSubset<T$1, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends SessionCreateArgs>(args: SelectSubset<T$1, SessionCreateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends SessionCreateManyAndReturnArgs>(args?: SelectSubset<T$1, SessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends SessionDeleteArgs>(args: SelectSubset<T$1, SessionDeleteArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionUpdateArgs>(args: SelectSubset<T$1, SessionUpdateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends SessionUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends SessionUpdateManyAndReturnArgs>(args: SelectSubset<T$1, SessionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends SessionUpsertArgs>(args: SelectSubset<T$1, SessionUpsertArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends SessionCountArgs>(args?: Subset<T$1, SessionCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends SessionAggregateArgs>(args: Subset<T$1, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T$1>>;

    /**
     * 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$1 extends SessionGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: SessionGroupByArgs['orderBy'];
    } : {
      orderBy?: SessionGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    readonly [Symbol.toStringTag]: "PrismaPromise";
    user<T$1 extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T$1, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1> | Null, Null, ExtArgs, GlobalOmitOptions$1>;
    /**
     * 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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends VerificationTokenAggregateArgs> = { [P in keyof T$1 & keyof AggregateVerificationToken]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateVerificationToken[P]> : GetScalarType<T$1[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$1 extends VerificationTokenGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<VerificationTokenGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof VerificationTokenGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], VerificationTokenGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | VerificationTokenDefaultArgs> = $Result.GetResult<Prisma.$VerificationTokenPayload, S$1>;
  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$1 = {}> {
    [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$1 extends VerificationTokenFindUniqueArgs>(args: SelectSubset<T$1, VerificationTokenFindUniqueArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenFindUniqueOrThrowArgs>(args: SelectSubset<T$1, VerificationTokenFindUniqueOrThrowArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenFindFirstArgs>(args?: SelectSubset<T$1, VerificationTokenFindFirstArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenFindFirstOrThrowArgs>(args?: SelectSubset<T$1, VerificationTokenFindFirstOrThrowArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenFindManyArgs>(args?: SelectSubset<T$1, VerificationTokenFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends VerificationTokenCreateArgs>(args: SelectSubset<T$1, VerificationTokenCreateArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends VerificationTokenCreateManyAndReturnArgs>(args?: SelectSubset<T$1, VerificationTokenCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends VerificationTokenDeleteArgs>(args: SelectSubset<T$1, VerificationTokenDeleteArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenUpdateArgs>(args: SelectSubset<T$1, VerificationTokenUpdateArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends VerificationTokenUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends VerificationTokenUpdateManyAndReturnArgs>(args: SelectSubset<T$1, VerificationTokenUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends VerificationTokenUpsertArgs>(args: SelectSubset<T$1, VerificationTokenUpsertArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends VerificationTokenCountArgs>(args?: Subset<T$1, VerificationTokenCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends VerificationTokenAggregateArgs>(args: Subset<T$1, VerificationTokenAggregateArgs>): Prisma.PrismaPromise<GetVerificationTokenAggregateType<T$1>>;

    /**
     * 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$1 extends VerificationTokenGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: VerificationTokenGroupByArgs['orderBy'];
    } : {
      orderBy?: VerificationTokenGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, VerificationTokenGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetVerificationTokenGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends WorkflowAuditLogAggregateArgs> = { [P in keyof T$1 & keyof AggregateWorkflowAuditLog]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateWorkflowAuditLog[P]> : GetScalarType<T$1[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$1 extends WorkflowAuditLogGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<WorkflowAuditLogGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof WorkflowAuditLogGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], WorkflowAuditLogGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | WorkflowAuditLogDefaultArgs> = $Result.GetResult<Prisma.$WorkflowAuditLogPayload, S$1>;
  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$1 = {}> {
    [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$1 extends WorkflowAuditLogFindUniqueArgs>(args: SelectSubset<T$1, WorkflowAuditLogFindUniqueArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogFindUniqueOrThrowArgs>(args: SelectSubset<T$1, WorkflowAuditLogFindUniqueOrThrowArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogFindFirstArgs>(args?: SelectSubset<T$1, WorkflowAuditLogFindFirstArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogFindFirstOrThrowArgs>(args?: SelectSubset<T$1, WorkflowAuditLogFindFirstOrThrowArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogFindManyArgs>(args?: SelectSubset<T$1, WorkflowAuditLogFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowAuditLogCreateArgs>(args: SelectSubset<T$1, WorkflowAuditLogCreateArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowAuditLogCreateManyAndReturnArgs>(args?: SelectSubset<T$1, WorkflowAuditLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowAuditLogDeleteArgs>(args: SelectSubset<T$1, WorkflowAuditLogDeleteArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogUpdateArgs>(args: SelectSubset<T$1, WorkflowAuditLogUpdateArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends WorkflowAuditLogUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends WorkflowAuditLogUpdateManyAndReturnArgs>(args: SelectSubset<T$1, WorkflowAuditLogUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends WorkflowAuditLogUpsertArgs>(args: SelectSubset<T$1, WorkflowAuditLogUpsertArgs<ExtArgs>>): Prisma__WorkflowAuditLogClient<$Result.GetResult<Prisma.$WorkflowAuditLogPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends WorkflowAuditLogCountArgs>(args?: Subset<T$1, WorkflowAuditLogCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends WorkflowAuditLogAggregateArgs>(args: Subset<T$1, WorkflowAuditLogAggregateArgs>): Prisma.PrismaPromise<GetWorkflowAuditLogAggregateType<T$1>>;

    /**
     * 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$1 extends WorkflowAuditLogGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: WorkflowAuditLogGroupByArgs['orderBy'];
    } : {
      orderBy?: WorkflowAuditLogGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, WorkflowAuditLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWorkflowAuditLogGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends HmacNonceAggregateArgs> = { [P in keyof T$1 & keyof AggregateHmacNonce]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateHmacNonce[P]> : GetScalarType<T$1[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$1 extends HmacNonceGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<HmacNonceGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof HmacNonceGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], HmacNonceGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | HmacNonceDefaultArgs> = $Result.GetResult<Prisma.$HmacNoncePayload, S$1>;
  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$1 = {}> {
    [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$1 extends HmacNonceFindUniqueArgs>(args: SelectSubset<T$1, HmacNonceFindUniqueArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceFindUniqueOrThrowArgs>(args: SelectSubset<T$1, HmacNonceFindUniqueOrThrowArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceFindFirstArgs>(args?: SelectSubset<T$1, HmacNonceFindFirstArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceFindFirstOrThrowArgs>(args?: SelectSubset<T$1, HmacNonceFindFirstOrThrowArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceFindManyArgs>(args?: SelectSubset<T$1, HmacNonceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends HmacNonceCreateArgs>(args: SelectSubset<T$1, HmacNonceCreateArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends HmacNonceCreateManyAndReturnArgs>(args?: SelectSubset<T$1, HmacNonceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends HmacNonceDeleteArgs>(args: SelectSubset<T$1, HmacNonceDeleteArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceUpdateArgs>(args: SelectSubset<T$1, HmacNonceUpdateArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends HmacNonceUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends HmacNonceUpdateManyAndReturnArgs>(args: SelectSubset<T$1, HmacNonceUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends HmacNonceUpsertArgs>(args: SelectSubset<T$1, HmacNonceUpsertArgs<ExtArgs>>): Prisma__HmacNonceClient<$Result.GetResult<Prisma.$HmacNoncePayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HmacNonceCountArgs>(args?: Subset<T$1, HmacNonceCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends HmacNonceAggregateArgs>(args: Subset<T$1, HmacNonceAggregateArgs>): Prisma.PrismaPromise<GetHmacNonceAggregateType<T$1>>;

    /**
     * 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$1 extends HmacNonceGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: HmacNonceGroupByArgs['orderBy'];
    } : {
      orderBy?: HmacNonceGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, HmacNonceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetHmacNonceGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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$1 extends HumanTaskAggregateArgs> = { [P in keyof T$1 & keyof AggregateHumanTask]: P extends '_count' | 'count' ? T$1[P] extends true ? number : GetScalarType<T$1[P], AggregateHumanTask[P]> : GetScalarType<T$1[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$1 extends HumanTaskGroupByArgs> = Prisma.PrismaPromise<Array<PickEnumerable<HumanTaskGroupByOutputType, T$1['by']> & { [P in ((keyof T$1) & (keyof HumanTaskGroupByOutputType))]: P extends '_count' ? T$1[P] extends boolean ? number : GetScalarType<T$1[P], HumanTaskGroupByOutputType[P]> : GetScalarType<T$1[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$1 extends boolean | null | undefined | HumanTaskDefaultArgs> = $Result.GetResult<Prisma.$HumanTaskPayload, S$1>;
  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$1 = {}> {
    [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$1 extends HumanTaskFindUniqueArgs>(args: SelectSubset<T$1, HumanTaskFindUniqueArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "findUnique", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskFindUniqueOrThrowArgs>(args: SelectSubset<T$1, HumanTaskFindUniqueOrThrowArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "findUniqueOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskFindFirstArgs>(args?: SelectSubset<T$1, HumanTaskFindFirstArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "findFirst", GlobalOmitOptions$1> | null, null, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskFindFirstOrThrowArgs>(args?: SelectSubset<T$1, HumanTaskFindFirstOrThrowArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "findFirstOrThrow", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskFindManyArgs>(args?: SelectSubset<T$1, HumanTaskFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "findMany", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends HumanTaskCreateArgs>(args: SelectSubset<T$1, HumanTaskCreateArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "create", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskCreateManyArgs>(args?: SelectSubset<T$1, 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$1 extends HumanTaskCreateManyAndReturnArgs>(args?: SelectSubset<T$1, HumanTaskCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "createManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends HumanTaskDeleteArgs>(args: SelectSubset<T$1, HumanTaskDeleteArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "delete", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskUpdateArgs>(args: SelectSubset<T$1, HumanTaskUpdateArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "update", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskDeleteManyArgs>(args?: SelectSubset<T$1, 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$1 extends HumanTaskUpdateManyArgs>(args: SelectSubset<T$1, 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$1 extends HumanTaskUpdateManyAndReturnArgs>(args: SelectSubset<T$1, HumanTaskUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "updateManyAndReturn", GlobalOmitOptions$1>>;

    /**
     * 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$1 extends HumanTaskUpsertArgs>(args: SelectSubset<T$1, HumanTaskUpsertArgs<ExtArgs>>): Prisma__HumanTaskClient<$Result.GetResult<Prisma.$HumanTaskPayload<ExtArgs>, T$1, "upsert", GlobalOmitOptions$1>, never, ExtArgs, GlobalOmitOptions$1>;

    /**
     * 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$1 extends HumanTaskCountArgs>(args?: Subset<T$1, HumanTaskCountArgs>): Prisma.PrismaPromise<T$1 extends $Utils.Record<'select', any> ? T$1['select'] extends true ? number : GetScalarType<T$1['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$1 extends HumanTaskAggregateArgs>(args: Subset<T$1, HumanTaskAggregateArgs>): Prisma.PrismaPromise<GetHumanTaskAggregateType<T$1>>;

    /**
     * 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$1 extends HumanTaskGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T$1>>, Extends<'take', Keys<T$1>>>, OrderByArg extends (True extends HasSelectOrTake ? {
      orderBy: HumanTaskGroupByArgs['orderBy'];
    } : {
      orderBy?: HumanTaskGroupByArgs['orderBy'];
    }), OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T$1['orderBy']>>>, ByFields extends MaybeTupleToUnion<T$1['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T$1['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends (T$1['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$1> ? 'orderBy' extends Keys<T$1> ? 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$1> ? 'orderBy' extends Keys<T$1> ? 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$1, HumanTaskGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetHumanTaskGroupByPayload<T$1> : 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$1, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions$1 = {}> extends Prisma.PrismaPromise<T$1> {
    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$1, TResult2 = never>(onfulfilled?: ((value: T$1) => 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$1 | 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$1>;
  }

  /**
   * 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: BaseDMMF;
}
//#endregion
//#region src/infrastructure/persistence/PrismaDatabaseClient.d.ts
type PrismaDatabaseClient = PrismaClient;
//#endregion
//#region src/bootstrap/runtime/AppConfigFactory.d.ts
declare class AppConfigFactory {
  private readonly pluginPackageMetadata;
  private readonly databaseUrlParser;
  create(args: Readonly<{
    repoRoot: string;
    consumerRoot: string;
    env: NodeJS.ProcessEnv;
    config: NormalizedCodemationConfig;
    workflowSources: ReadonlyArray<string>;
  }>): AppConfig;
  private createConfiguredPluginLoadSummary;
  private resolvePersistence;
  private resolveSchedulerKind;
  private resolveEventBusKind;
  private readSchedulerKind;
  private readEventBusKind;
}
//#endregion
export { PrismaDatabaseClient as n, PrismaClient as r, AppConfigFactory as t };
//# sourceMappingURL=AppConfigFactory-DZjtXivd.d.ts.map