diff --git "a/ui/node_modules/.prisma/client/index.d.ts" "b/ui/node_modules/.prisma/client/index.d.ts" new file mode 100644--- /dev/null +++ "b/ui/node_modules/.prisma/client/index.d.ts" @@ -0,0 +1,5251 @@ + +/** + * Client +**/ + +import * as runtime from '@prisma/client/runtime/library.js'; +import $Types = runtime.Types // general types +import $Public = runtime.Types.Public +import $Utils = runtime.Types.Utils +import $Extensions = runtime.Types.Extensions +import $Result = runtime.Types.Result + +export type PrismaPromise = $Public.PrismaPromise + + +/** + * Model Settings + * + */ +export type Settings = $Result.DefaultSelection +/** + * Model Queue + * + */ +export type Queue = $Result.DefaultSelection +/** + * Model Job + * + */ +export type Job = $Result.DefaultSelection + +/** + * ## Prisma Client ʲˢ + * + * Type-safe database client for TypeScript & Node.js + * @example + * ``` + * const prisma = new PrismaClient() + * // Fetch zero or more Settings + * const settings = await prisma.settings.findMany() + * ``` + * + * + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). + */ +export class PrismaClient< + ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions, + U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array ? Prisma.GetEvents : never : never, + ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs +> { + [K: symbol]: { types: Prisma.TypeMap['other'] } + + /** + * ## Prisma Client ʲˢ + * + * Type-safe database client for TypeScript & Node.js + * @example + * ``` + * const prisma = new PrismaClient() + * // Fetch zero or more Settings + * const settings = await prisma.settings.findMany() + * ``` + * + * + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). + */ + + constructor(optionsArg ?: Prisma.Subset); + $on(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void; + + /** + * Connect with the database + */ + $connect(): $Utils.JsPromise; + + /** + * Disconnect from the database + */ + $disconnect(): $Utils.JsPromise; + + /** + * Add a middleware + * @deprecated since 4.16.0. For new code, prefer client extensions instead. + * @see https://pris.ly/d/extensions + */ + $use(cb: Prisma.Middleware): void + +/** + * Executes a prepared raw query and returns the number of affected rows. + * @example + * ``` + * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};` + * ``` + * + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). + */ + $executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise; + + /** + * Executes a raw query and returns the number of affected rows. + * Susceptible to SQL injections, see documentation. + * @example + * ``` + * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com') + * ``` + * + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). + */ + $executeRawUnsafe(query: string, ...values: any[]): Prisma.PrismaPromise; + + /** + * Performs a prepared raw query and returns the `SELECT` data. + * @example + * ``` + * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};` + * ``` + * + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). + */ + $queryRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise; + + /** + * Performs a raw query and returns the `SELECT` data. + * Susceptible to SQL injections, see documentation. + * @example + * ``` + * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com') + * ``` + * + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). + */ + $queryRawUnsafe(query: string, ...values: any[]): Prisma.PrismaPromise; + + + /** + * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole. + * @example + * ``` + * const [george, bob, alice] = await prisma.$transaction([ + * prisma.user.create({ data: { name: 'George' } }), + * prisma.user.create({ data: { name: 'Bob' } }), + * prisma.user.create({ data: { name: 'Alice' } }), + * ]) + * ``` + * + * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions). + */ + $transaction

[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise> + + $transaction(fn: (prisma: Omit) => $Utils.JsPromise, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise + + + $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs, $Utils.Call, ClientOptions> + + /** + * `prisma.settings`: Exposes CRUD operations for the **Settings** model. + * Example usage: + * ```ts + * // Fetch zero or more Settings + * const settings = await prisma.settings.findMany() + * ``` + */ + get settings(): Prisma.SettingsDelegate; + + /** + * `prisma.queue`: Exposes CRUD operations for the **Queue** model. + * Example usage: + * ```ts + * // Fetch zero or more Queues + * const queues = await prisma.queue.findMany() + * ``` + */ + get queue(): Prisma.QueueDelegate; + + /** + * `prisma.job`: Exposes CRUD operations for the **Job** model. + * Example usage: + * ```ts + * // Fetch zero or more Jobs + * const jobs = await prisma.job.findMany() + * ``` + */ + get job(): Prisma.JobDelegate; +} + +export namespace Prisma { + export import DMMF = runtime.DMMF + + export type PrismaPromise = $Public.PrismaPromise + + /** + * Validator + */ + export import validator = runtime.Public.validator + + /** + * Prisma Errors + */ + export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError + export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError + export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError + export import PrismaClientInitializationError = runtime.PrismaClientInitializationError + export import PrismaClientValidationError = runtime.PrismaClientValidationError + + /** + * Re-export of sql-template-tag + */ + export import sql = runtime.sqltag + export import empty = runtime.empty + export import join = runtime.join + export import raw = runtime.raw + export import Sql = runtime.Sql + + + + /** + * Decimal.js + */ + export import Decimal = runtime.Decimal + + export type DecimalJsLike = runtime.DecimalJsLike + + /** + * Metrics + */ + export type Metrics = runtime.Metrics + export type Metric = runtime.Metric + export type MetricHistogram = runtime.MetricHistogram + export type MetricHistogramBucket = runtime.MetricHistogramBucket + + /** + * Extensions + */ + export import Extension = $Extensions.UserArgs + export import getExtensionContext = runtime.Extensions.getExtensionContext + export import Args = $Public.Args + export import Payload = $Public.Payload + export import Result = $Public.Result + export import Exact = $Public.Exact + + /** + * Prisma Client JS version: 6.3.1 + * Query Engine version: acc0b9dd43eb689cbd20c9470515d719db10d0b0 + */ + export type PrismaVersion = { + client: string + } + + export const prismaVersion: PrismaVersion + + /** + * Utility Types + */ + + + export import JsonObject = runtime.JsonObject + export import JsonArray = runtime.JsonArray + export import JsonValue = runtime.JsonValue + export import InputJsonObject = runtime.InputJsonObject + export import InputJsonArray = runtime.InputJsonArray + export import InputJsonValue = runtime.InputJsonValue + + /** + * Types of the values used to represent different kinds of `null` values when working with JSON fields. + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + namespace NullTypes { + /** + * Type of `Prisma.DbNull`. + * + * You cannot use other instances of this class. Please use the `Prisma.DbNull` value. + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + class DbNull { + private DbNull: never + private constructor() + } + + /** + * Type of `Prisma.JsonNull`. + * + * You cannot use other instances of this class. Please use the `Prisma.JsonNull` value. + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + class JsonNull { + private JsonNull: never + private constructor() + } + + /** + * Type of `Prisma.AnyNull`. + * + * You cannot use other instances of this class. Please use the `Prisma.AnyNull` value. + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + class AnyNull { + private AnyNull: never + private constructor() + } + } + + /** + * Helper for filtering JSON entries that have `null` on the database (empty on the db) + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + export const DbNull: NullTypes.DbNull + + /** + * Helper for filtering JSON entries that have JSON `null` values (not empty on the db) + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + export const JsonNull: NullTypes.JsonNull + + /** + * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull` + * + * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field + */ + export const AnyNull: NullTypes.AnyNull + + type SelectAndInclude = { + select: any + include: any + } + + type SelectAndOmit = { + select: any + omit: any + } + + /** + * Get the type of the value, that the Promise holds. + */ + export type PromiseType> = T extends PromiseLike ? U : T; + + /** + * Get the return type of a function which returns a Promise. + */ + export type PromiseReturnType $Utils.JsPromise> = PromiseType> + + /** + * From T, pick a set of properties whose keys are in the union K + */ + type Prisma__Pick = { + [P in K]: T[P]; + }; + + + export type Enumerable = T | Array; + + export type RequiredKeys = { + [K in keyof T]-?: {} extends Prisma__Pick ? never : K + }[keyof T] + + export type TruthyKeys = keyof { + [K in keyof T as T[K] extends false | undefined | null ? never : K]: K + } + + export type TrueKeys = TruthyKeys>> + + /** + * Subset + * @desc From `T` pick properties that exist in `U`. Simple version of Intersection + */ + export type Subset = { + [key in keyof T]: key extends keyof U ? T[key] : never; + }; + + /** + * SelectSubset + * @desc From `T` pick properties that exist in `U`. Simple version of Intersection. + * Additionally, it validates, if both select and include are present. If the case, it errors. + */ + export type SelectSubset = { + [key in keyof T]: key extends keyof U ? T[key] : never + } & + (T extends SelectAndInclude + ? 'Please either choose `select` or `include`.' + : T extends SelectAndOmit + ? 'Please either choose `select` or `omit`.' + : {}) + + /** + * Subset + Intersection + * @desc From `T` pick properties that exist in `U` and intersect `K` + */ + export type SubsetIntersection = { + [key in keyof T]: key extends keyof U ? T[key] : never + } & + K + + type Without = { [P in Exclude]?: 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 extends object ? + U extends object ? + (Without & U) | (Without & T) + : U : T + + + /** + * Is T a Record? + */ + type IsObject = T extends Array + ? False + : T extends Date + ? False + : T extends Uint8Array + ? False + : T extends BigInt + ? False + : T extends object + ? True + : False + + + /** + * If it's T[], return T + */ + export type UnEnumerate = T extends Array ? U : T + + /** + * From ts-toolbelt + */ + + type __Either = Omit & + { + // Merge all but K + [P in K]: Prisma__Pick // With K possibilities + }[K] + + type EitherStrict = Strict<__Either> + + type EitherLoose = ComputeRaw<__Either> + + type _Either< + O extends object, + K extends Key, + strict extends Boolean + > = { + 1: EitherStrict + 0: EitherLoose + }[strict] + + type Either< + O extends object, + K extends Key, + strict extends Boolean = 1 + > = O extends unknown ? _Either : never + + export type Union = any + + type PatchUndefined = { + [K in keyof O]: O[K] extends undefined ? At : O[K] + } & {} + + /** Helper Types for "Merge" **/ + export type IntersectOf = ( + U extends unknown ? (k: U) => void : never + ) extends (k: infer I) => void + ? I + : never + + export type Overwrite = { + [K in keyof O]: K extends keyof O1 ? O1[K] : O[K]; + } & {}; + + type _Merge = IntersectOf; + }>>; + + type Key = string | number | symbol; + type AtBasic = K extends keyof O ? O[K] : never; + type AtStrict = O[K & keyof O]; + type AtLoose = O extends unknown ? AtStrict : never; + export type At = { + 1: AtStrict; + 0: AtLoose; + }[strict]; + + export type ComputeRaw = A extends Function ? A : { + [K in keyof A]: A[K]; + } & {}; + + export type OptionalFlat = { + [K in keyof O]?: O[K]; + } & {}; + + type _Record = { + [P in K]: T; + }; + + // cause typescript not to expand types and preserve names + type NoExpand = T extends unknown ? T : never; + + // this type assumes the passed object is entirely optional + type AtLeast = NoExpand< + O extends unknown + ? | (K extends keyof O ? { [P in K]: O[P] } & O : O) + | {[P in keyof O as P extends K ? K : never]-?: O[P]} & O + : never>; + + type _Strict = U extends unknown ? U & OptionalFlat<_Record, keyof U>, never>> : never; + + export type Strict = ComputeRaw<_Strict>; + /** End Helper Types for "Merge" **/ + + export type Merge = ComputeRaw<_Merge>>; + + /** + A [[Boolean]] + */ + export type Boolean = True | False + + // /** + // 1 + // */ + export type True = 1 + + /** + 0 + */ + export type False = 0 + + export type Not = { + 0: 1 + 1: 0 + }[B] + + export type Extends = [A1] extends [never] + ? 0 // anything `never` is false + : A1 extends A2 + ? 1 + : 0 + + export type Has = Not< + Extends, U1> + > + + export type Or = { + 0: { + 0: 0 + 1: 1 + } + 1: { + 0: 1 + 1: 1 + } + }[B1][B2] + + export type Keys = U extends unknown ? keyof U : never + + type Cast = A extends B ? A : B; + + export const type: unique symbol; + + + + /** + * Used by group by + */ + + export type GetScalarType = O extends object ? { + [P in keyof T]: P extends keyof O + ? O[P] + : never + } : never + + type FieldPaths< + T, + U = Omit + > = IsObject extends True ? U : T + + type GetHavingFields = { + [K in keyof T]: Or< + Or, Extends<'AND', K>>, + Extends<'NOT', K> + > extends True + ? // infer is only needed to not hit TS limit + // based on the brilliant idea of Pierre-Antoine Mills + // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437 + T[K] extends infer TK + ? GetHavingFields extends object ? Merge> : never> + : never + : {} extends FieldPaths + ? never + : K + }[keyof T] + + /** + * Convert tuple to union + */ + type _TupleToUnion = T extends (infer E)[] ? E : never + type TupleToUnion = _TupleToUnion + type MaybeTupleToUnion = T extends any[] ? TupleToUnion : T + + /** + * Like `Pick`, but additionally can also accept an array of keys + */ + type PickEnumerable | keyof T> = Prisma__Pick> + + /** + * Exclude all keys with underscores + */ + type ExcludeUnderscoreKeys = T extends `_${string}` ? never : T + + + export type FieldRef = runtime.FieldRef + + type FieldRefInputType = Model extends never ? never : FieldRef + + + export const ModelName: { + Settings: 'Settings', + Queue: 'Queue', + Job: 'Job' + }; + + export type ModelName = (typeof ModelName)[keyof typeof ModelName] + + + export type Datasources = { + db?: Datasource + } + + interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record> { + returns: Prisma.TypeMap + } + + export type TypeMap = { + meta: { + modelProps: "settings" | "queue" | "job" + txIsolationLevel: Prisma.TransactionIsolationLevel + } + model: { + Settings: { + payload: Prisma.$SettingsPayload + fields: Prisma.SettingsFieldRefs + operations: { + findUnique: { + args: Prisma.SettingsFindUniqueArgs + result: $Utils.PayloadToResult | null + } + findUniqueOrThrow: { + args: Prisma.SettingsFindUniqueOrThrowArgs + result: $Utils.PayloadToResult + } + findFirst: { + args: Prisma.SettingsFindFirstArgs + result: $Utils.PayloadToResult | null + } + findFirstOrThrow: { + args: Prisma.SettingsFindFirstOrThrowArgs + result: $Utils.PayloadToResult + } + findMany: { + args: Prisma.SettingsFindManyArgs + result: $Utils.PayloadToResult[] + } + create: { + args: Prisma.SettingsCreateArgs + result: $Utils.PayloadToResult + } + createMany: { + args: Prisma.SettingsCreateManyArgs + result: BatchPayload + } + createManyAndReturn: { + args: Prisma.SettingsCreateManyAndReturnArgs + result: $Utils.PayloadToResult[] + } + delete: { + args: Prisma.SettingsDeleteArgs + result: $Utils.PayloadToResult + } + update: { + args: Prisma.SettingsUpdateArgs + result: $Utils.PayloadToResult + } + deleteMany: { + args: Prisma.SettingsDeleteManyArgs + result: BatchPayload + } + updateMany: { + args: Prisma.SettingsUpdateManyArgs + result: BatchPayload + } + updateManyAndReturn: { + args: Prisma.SettingsUpdateManyAndReturnArgs + result: $Utils.PayloadToResult[] + } + upsert: { + args: Prisma.SettingsUpsertArgs + result: $Utils.PayloadToResult + } + aggregate: { + args: Prisma.SettingsAggregateArgs + result: $Utils.Optional + } + groupBy: { + args: Prisma.SettingsGroupByArgs + result: $Utils.Optional[] + } + count: { + args: Prisma.SettingsCountArgs + result: $Utils.Optional | number + } + } + } + Queue: { + payload: Prisma.$QueuePayload + fields: Prisma.QueueFieldRefs + operations: { + findUnique: { + args: Prisma.QueueFindUniqueArgs + result: $Utils.PayloadToResult | null + } + findUniqueOrThrow: { + args: Prisma.QueueFindUniqueOrThrowArgs + result: $Utils.PayloadToResult + } + findFirst: { + args: Prisma.QueueFindFirstArgs + result: $Utils.PayloadToResult | null + } + findFirstOrThrow: { + args: Prisma.QueueFindFirstOrThrowArgs + result: $Utils.PayloadToResult + } + findMany: { + args: Prisma.QueueFindManyArgs + result: $Utils.PayloadToResult[] + } + create: { + args: Prisma.QueueCreateArgs + result: $Utils.PayloadToResult + } + createMany: { + args: Prisma.QueueCreateManyArgs + result: BatchPayload + } + createManyAndReturn: { + args: Prisma.QueueCreateManyAndReturnArgs + result: $Utils.PayloadToResult[] + } + delete: { + args: Prisma.QueueDeleteArgs + result: $Utils.PayloadToResult + } + update: { + args: Prisma.QueueUpdateArgs + result: $Utils.PayloadToResult + } + deleteMany: { + args: Prisma.QueueDeleteManyArgs + result: BatchPayload + } + updateMany: { + args: Prisma.QueueUpdateManyArgs + result: BatchPayload + } + updateManyAndReturn: { + args: Prisma.QueueUpdateManyAndReturnArgs + result: $Utils.PayloadToResult[] + } + upsert: { + args: Prisma.QueueUpsertArgs + result: $Utils.PayloadToResult + } + aggregate: { + args: Prisma.QueueAggregateArgs + result: $Utils.Optional + } + groupBy: { + args: Prisma.QueueGroupByArgs + result: $Utils.Optional[] + } + count: { + args: Prisma.QueueCountArgs + result: $Utils.Optional | number + } + } + } + Job: { + payload: Prisma.$JobPayload + fields: Prisma.JobFieldRefs + operations: { + findUnique: { + args: Prisma.JobFindUniqueArgs + result: $Utils.PayloadToResult | null + } + findUniqueOrThrow: { + args: Prisma.JobFindUniqueOrThrowArgs + result: $Utils.PayloadToResult + } + findFirst: { + args: Prisma.JobFindFirstArgs + result: $Utils.PayloadToResult | null + } + findFirstOrThrow: { + args: Prisma.JobFindFirstOrThrowArgs + result: $Utils.PayloadToResult + } + findMany: { + args: Prisma.JobFindManyArgs + result: $Utils.PayloadToResult[] + } + create: { + args: Prisma.JobCreateArgs + result: $Utils.PayloadToResult + } + createMany: { + args: Prisma.JobCreateManyArgs + result: BatchPayload + } + createManyAndReturn: { + args: Prisma.JobCreateManyAndReturnArgs + result: $Utils.PayloadToResult[] + } + delete: { + args: Prisma.JobDeleteArgs + result: $Utils.PayloadToResult + } + update: { + args: Prisma.JobUpdateArgs + result: $Utils.PayloadToResult + } + deleteMany: { + args: Prisma.JobDeleteManyArgs + result: BatchPayload + } + updateMany: { + args: Prisma.JobUpdateManyArgs + result: BatchPayload + } + updateManyAndReturn: { + args: Prisma.JobUpdateManyAndReturnArgs + result: $Utils.PayloadToResult[] + } + upsert: { + args: Prisma.JobUpsertArgs + result: $Utils.PayloadToResult + } + aggregate: { + args: Prisma.JobAggregateArgs + result: $Utils.Optional + } + groupBy: { + args: Prisma.JobGroupByArgs + result: $Utils.Optional[] + } + count: { + args: Prisma.JobCountArgs + result: $Utils.Optional | number + } + } + } + } + } & { + other: { + payload: any + operations: { + $executeRaw: { + args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]], + result: any + } + $executeRawUnsafe: { + args: [query: string, ...values: any[]], + result: any + } + $queryRaw: { + args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]], + result: any + } + $queryRawUnsafe: { + args: [query: string, ...values: any[]], + result: any + } + } + } + } + export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs> + export type DefaultPrismaClient = PrismaClient + export type ErrorFormat = 'pretty' | 'colorless' | 'minimal' + export interface PrismaClientOptions { + /** + * Overwrites the datasource url from your schema.prisma file + */ + datasources?: Datasources + /** + * Overwrites the datasource url from your schema.prisma file + */ + datasourceUrl?: string + /** + * @default "colorless" + */ + errorFormat?: ErrorFormat + /** + * @example + * ``` + * // Defaults to stdout + * log: ['query', 'info', 'warn', 'error'] + * + * // Emit as events + * log: [ + * { emit: 'stdout', level: 'query' }, + * { emit: 'stdout', level: 'info' }, + * { emit: 'stdout', level: 'warn' } + * { emit: 'stdout', level: 'error' } + * ] + * ``` + * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option). + */ + log?: (LogLevel | LogDefinition)[] + /** + * The default values for transactionOptions + * maxWait ?= 2000 + * timeout ?= 5000 + */ + transactionOptions?: { + maxWait?: number + timeout?: number + isolationLevel?: Prisma.TransactionIsolationLevel + } + /** + * Global configuration for omitting model fields by default. + * + * @example + * ``` + * const prisma = new PrismaClient({ + * omit: { + * user: { + * password: true + * } + * } + * }) + * ``` + */ + omit?: Prisma.GlobalOmitConfig + } + export type GlobalOmitConfig = { + settings?: SettingsOmit + queue?: QueueOmit + job?: JobOmit + } + + /* Types for Logging */ + export type LogLevel = 'info' | 'query' | 'warn' | 'error' + export type LogDefinition = { + level: LogLevel + emit: 'stdout' | 'event' + } + + export type GetLogType = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never + export type GetEvents = T extends Array ? + GetLogType | GetLogType | GetLogType | GetLogType + : never + + export type QueryEvent = { + timestamp: Date + query: string + params: string + duration: number + target: string + } + + export type LogEvent = { + timestamp: Date + message: string + target: string + } + /* End Types for Logging */ + + + export type PrismaAction = + | 'findUnique' + | 'findUniqueOrThrow' + | 'findMany' + | 'findFirst' + | 'findFirstOrThrow' + | 'create' + | 'createMany' + | 'createManyAndReturn' + | 'update' + | 'updateMany' + | 'updateManyAndReturn' + | 'upsert' + | 'delete' + | 'deleteMany' + | 'executeRaw' + | 'queryRaw' + | 'aggregate' + | 'count' + | 'runCommandRaw' + | 'findRaw' + | 'groupBy' + + /** + * These options are being passed into the middleware as "params" + */ + export type MiddlewareParams = { + model?: ModelName + action: PrismaAction + args: any + dataPath: string[] + runInTransaction: boolean + } + + /** + * The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation + */ + export type Middleware = ( + params: MiddlewareParams, + next: (params: MiddlewareParams) => $Utils.JsPromise, + ) => $Utils.JsPromise + + // tested in getLogLevel.test.ts + export function getLogLevel(log: Array): LogLevel | undefined; + + /** + * `PrismaClient` proxy available in interactive transactions. + */ + export type TransactionClient = Omit + + export type Datasource = { + url?: string + } + + /** + * Count Types + */ + + + + /** + * Models + */ + + /** + * Model Settings + */ + + export type AggregateSettings = { + _count: SettingsCountAggregateOutputType | null + _avg: SettingsAvgAggregateOutputType | null + _sum: SettingsSumAggregateOutputType | null + _min: SettingsMinAggregateOutputType | null + _max: SettingsMaxAggregateOutputType | null + } + + export type SettingsAvgAggregateOutputType = { + id: number | null + } + + export type SettingsSumAggregateOutputType = { + id: number | null + } + + export type SettingsMinAggregateOutputType = { + id: number | null + key: string | null + value: string | null + } + + export type SettingsMaxAggregateOutputType = { + id: number | null + key: string | null + value: string | null + } + + export type SettingsCountAggregateOutputType = { + id: number + key: number + value: number + _all: number + } + + + export type SettingsAvgAggregateInputType = { + id?: true + } + + export type SettingsSumAggregateInputType = { + id?: true + } + + export type SettingsMinAggregateInputType = { + id?: true + key?: true + value?: true + } + + export type SettingsMaxAggregateInputType = { + id?: true + key?: true + value?: true + } + + export type SettingsCountAggregateInputType = { + id?: true + key?: true + value?: true + _all?: true + } + + export type SettingsAggregateArgs = { + /** + * Filter which Settings to aggregate. + */ + where?: SettingsWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Settings to fetch. + */ + orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the start position + */ + cursor?: SettingsWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Settings from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Settings. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Count returned Settings + **/ + _count?: true | SettingsCountAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to average + **/ + _avg?: SettingsAvgAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to sum + **/ + _sum?: SettingsSumAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to find the minimum value + **/ + _min?: SettingsMinAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to find the maximum value + **/ + _max?: SettingsMaxAggregateInputType + } + + export type GetSettingsAggregateType = { + [P in keyof T & keyof AggregateSettings]: P extends '_count' | 'count' + ? T[P] extends true + ? number + : GetScalarType + : GetScalarType + } + + + + + export type SettingsGroupByArgs = { + where?: SettingsWhereInput + orderBy?: SettingsOrderByWithAggregationInput | SettingsOrderByWithAggregationInput[] + by: SettingsScalarFieldEnum[] | SettingsScalarFieldEnum + having?: SettingsScalarWhereWithAggregatesInput + take?: number + skip?: number + _count?: SettingsCountAggregateInputType | true + _avg?: SettingsAvgAggregateInputType + _sum?: SettingsSumAggregateInputType + _min?: SettingsMinAggregateInputType + _max?: SettingsMaxAggregateInputType + } + + export type SettingsGroupByOutputType = { + id: number + key: string + value: string + _count: SettingsCountAggregateOutputType | null + _avg: SettingsAvgAggregateOutputType | null + _sum: SettingsSumAggregateOutputType | null + _min: SettingsMinAggregateOutputType | null + _max: SettingsMaxAggregateOutputType | null + } + + type GetSettingsGroupByPayload = Prisma.PrismaPromise< + Array< + PickEnumerable & + { + [P in ((keyof T) & (keyof SettingsGroupByOutputType))]: P extends '_count' + ? T[P] extends boolean + ? number + : GetScalarType + : GetScalarType + } + > + > + + + export type SettingsSelect = $Extensions.GetSelect<{ + id?: boolean + key?: boolean + value?: boolean + }, ExtArgs["result"]["settings"]> + + export type SettingsSelectCreateManyAndReturn = $Extensions.GetSelect<{ + id?: boolean + key?: boolean + value?: boolean + }, ExtArgs["result"]["settings"]> + + export type SettingsSelectUpdateManyAndReturn = $Extensions.GetSelect<{ + id?: boolean + key?: boolean + value?: boolean + }, ExtArgs["result"]["settings"]> + + export type SettingsSelectScalar = { + id?: boolean + key?: boolean + value?: boolean + } + + export type SettingsOmit = $Extensions.GetOmit<"id" | "key" | "value", ExtArgs["result"]["settings"]> + + export type $SettingsPayload = { + name: "Settings" + objects: {} + scalars: $Extensions.GetPayloadResult<{ + id: number + key: string + value: string + }, ExtArgs["result"]["settings"]> + composites: {} + } + + type SettingsGetPayload = $Result.GetResult + + type SettingsCountArgs = + Omit & { + select?: SettingsCountAggregateInputType | true + } + + export interface SettingsDelegate { + [K: symbol]: { types: Prisma.TypeMap['model']['Settings'], meta: { name: 'Settings' } } + /** + * Find zero or one Settings that matches the filter. + * @param {SettingsFindUniqueArgs} args - Arguments to find a Settings + * @example + * // Get one Settings + * const settings = await prisma.settings.findUnique({ + * where: { + * // ... provide filter here + * } + * }) + */ + findUnique(args: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "findUnique", ClientOptions> | null, null, ExtArgs, ClientOptions> + + /** + * Find one Settings that matches the filter or throw an error with `error.code='P2025'` + * if no matches were found. + * @param {SettingsFindUniqueOrThrowArgs} args - Arguments to find a Settings + * @example + * // Get one Settings + * const settings = await prisma.settings.findUniqueOrThrow({ + * where: { + * // ... provide filter here + * } + * }) + */ + findUniqueOrThrow(args: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "findUniqueOrThrow", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Find the first Settings 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 {SettingsFindFirstArgs} args - Arguments to find a Settings + * @example + * // Get one Settings + * const settings = await prisma.settings.findFirst({ + * where: { + * // ... provide filter here + * } + * }) + */ + findFirst(args?: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "findFirst", ClientOptions> | null, null, ExtArgs, ClientOptions> + + /** + * Find the first Settings 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 {SettingsFindFirstOrThrowArgs} args - Arguments to find a Settings + * @example + * // Get one Settings + * const settings = await prisma.settings.findFirstOrThrow({ + * where: { + * // ... provide filter here + * } + * }) + */ + findFirstOrThrow(args?: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "findFirstOrThrow", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Find zero or more Settings 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 {SettingsFindManyArgs} args - Arguments to filter and select certain fields only. + * @example + * // Get all Settings + * const settings = await prisma.settings.findMany() + * + * // Get first 10 Settings + * const settings = await prisma.settings.findMany({ take: 10 }) + * + * // Only select the `id` + * const settingsWithIdOnly = await prisma.settings.findMany({ select: { id: true } }) + * + */ + findMany(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "findMany", ClientOptions>> + + /** + * Create a Settings. + * @param {SettingsCreateArgs} args - Arguments to create a Settings. + * @example + * // Create one Settings + * const Settings = await prisma.settings.create({ + * data: { + * // ... data to create a Settings + * } + * }) + * + */ + create(args: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "create", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Create many Settings. + * @param {SettingsCreateManyArgs} args - Arguments to create many Settings. + * @example + * // Create many Settings + * const settings = await prisma.settings.createMany({ + * data: [ + * // ... provide data here + * ] + * }) + * + */ + createMany(args?: SelectSubset>): Prisma.PrismaPromise + + /** + * Create many Settings and returns the data saved in the database. + * @param {SettingsCreateManyAndReturnArgs} args - Arguments to create many Settings. + * @example + * // Create many Settings + * const settings = await prisma.settings.createManyAndReturn({ + * data: [ + * // ... provide data here + * ] + * }) + * + * // Create many Settings and only return the `id` + * const settingsWithIdOnly = await prisma.settings.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(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "createManyAndReturn", ClientOptions>> + + /** + * Delete a Settings. + * @param {SettingsDeleteArgs} args - Arguments to delete one Settings. + * @example + * // Delete one Settings + * const Settings = await prisma.settings.delete({ + * where: { + * // ... filter to delete one Settings + * } + * }) + * + */ + delete(args: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "delete", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Update one Settings. + * @param {SettingsUpdateArgs} args - Arguments to update one Settings. + * @example + * // Update one Settings + * const settings = await prisma.settings.update({ + * where: { + * // ... provide filter here + * }, + * data: { + * // ... provide data here + * } + * }) + * + */ + update(args: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "update", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Delete zero or more Settings. + * @param {SettingsDeleteManyArgs} args - Arguments to filter Settings to delete. + * @example + * // Delete a few Settings + * const { count } = await prisma.settings.deleteMany({ + * where: { + * // ... provide filter here + * } + * }) + * + */ + deleteMany(args?: SelectSubset>): Prisma.PrismaPromise + + /** + * Update zero or more Settings. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {SettingsUpdateManyArgs} args - Arguments to update one or more rows. + * @example + * // Update many Settings + * const settings = await prisma.settings.updateMany({ + * where: { + * // ... provide filter here + * }, + * data: { + * // ... provide data here + * } + * }) + * + */ + updateMany(args: SelectSubset>): Prisma.PrismaPromise + + /** + * Update zero or more Settings and returns the data updated in the database. + * @param {SettingsUpdateManyAndReturnArgs} args - Arguments to update many Settings. + * @example + * // Update many Settings + * const settings = await prisma.settings.updateManyAndReturn({ + * where: { + * // ... provide filter here + * }, + * data: [ + * // ... provide data here + * ] + * }) + * + * // Update zero or more Settings and only return the `id` + * const settingsWithIdOnly = await prisma.settings.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(args: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "updateManyAndReturn", ClientOptions>> + + /** + * Create or update one Settings. + * @param {SettingsUpsertArgs} args - Arguments to update or create a Settings. + * @example + * // Update or create a Settings + * const settings = await prisma.settings.upsert({ + * create: { + * // ... data to create a Settings + * }, + * update: { + * // ... in case it already exists, update + * }, + * where: { + * // ... the filter for the Settings we want to update + * } + * }) + */ + upsert(args: SelectSubset>): Prisma__SettingsClient<$Result.GetResult, T, "upsert", ClientOptions>, never, ExtArgs, ClientOptions> + + + /** + * Count the number of Settings. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {SettingsCountArgs} args - Arguments to filter Settings to count. + * @example + * // Count the number of Settings + * const count = await prisma.settings.count({ + * where: { + * // ... the filter for the Settings we want to count + * } + * }) + **/ + count( + args?: Subset, + ): Prisma.PrismaPromise< + T extends $Utils.Record<'select', any> + ? T['select'] extends true + ? number + : GetScalarType + : number + > + + /** + * Allows you to perform aggregations operations on a Settings. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {SettingsAggregateArgs} 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(args: Subset): Prisma.PrismaPromise> + + /** + * Group by Settings. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {SettingsGroupByArgs} args - Group by arguments. + * @example + * // Group by city, order by createdAt, get count + * const result = await prisma.user.groupBy({ + * by: ['city', 'createdAt'], + * orderBy: { + * createdAt: true + * }, + * _count: { + * _all: true + * }, + * }) + * + **/ + groupBy< + T extends SettingsGroupByArgs, + HasSelectOrTake extends Or< + Extends<'skip', Keys>, + Extends<'take', Keys> + >, + OrderByArg extends True extends HasSelectOrTake + ? { orderBy: SettingsGroupByArgs['orderBy'] } + : { orderBy?: SettingsGroupByArgs['orderBy'] }, + OrderFields extends ExcludeUnderscoreKeys>>, + ByFields extends MaybeTupleToUnion, + ByValid extends Has, + HavingFields extends GetHavingFields, + HavingValid extends Has, + ByEmpty extends T['by'] extends never[] ? True : False, + InputErrors extends ByEmpty extends True + ? `Error: "by" must not be empty.` + : HavingValid extends False + ? { + [P in HavingFields]: P extends ByFields + ? never + : P extends string + ? `Error: Field "${P}" used in "having" needs to be provided in "by".` + : [ + Error, + 'Field ', + P, + ` in "having" needs to be provided in "by"`, + ] + }[HavingFields] + : 'take' extends Keys + ? 'orderBy' extends Keys + ? 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 + ? 'orderBy' extends Keys + ? 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 & InputErrors): {} extends InputErrors ? GetSettingsGroupByPayload : Prisma.PrismaPromise + /** + * Fields of the Settings model + */ + readonly fields: SettingsFieldRefs; + } + + /** + * The delegate class that acts as a "Promise-like" for Settings. + * 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__SettingsClient extends Prisma.PrismaPromise { + 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(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): $Utils.JsPromise + /** + * 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(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): $Utils.JsPromise + /** + * 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 + } + + + + + /** + * Fields of the Settings model + */ + interface SettingsFieldRefs { + readonly id: FieldRef<"Settings", 'Int'> + readonly key: FieldRef<"Settings", 'String'> + readonly value: FieldRef<"Settings", 'String'> + } + + + // Custom InputTypes + /** + * Settings findUnique + */ + export type SettingsFindUniqueArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * Filter, which Settings to fetch. + */ + where: SettingsWhereUniqueInput + } + + /** + * Settings findUniqueOrThrow + */ + export type SettingsFindUniqueOrThrowArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * Filter, which Settings to fetch. + */ + where: SettingsWhereUniqueInput + } + + /** + * Settings findFirst + */ + export type SettingsFindFirstArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * Filter, which Settings to fetch. + */ + where?: SettingsWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Settings to fetch. + */ + orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for searching for Settings. + */ + cursor?: SettingsWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Settings from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Settings. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} + * + * Filter by unique combinations of Settings. + */ + distinct?: SettingsScalarFieldEnum | SettingsScalarFieldEnum[] + } + + /** + * Settings findFirstOrThrow + */ + export type SettingsFindFirstOrThrowArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * Filter, which Settings to fetch. + */ + where?: SettingsWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Settings to fetch. + */ + orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for searching for Settings. + */ + cursor?: SettingsWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Settings from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Settings. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} + * + * Filter by unique combinations of Settings. + */ + distinct?: SettingsScalarFieldEnum | SettingsScalarFieldEnum[] + } + + /** + * Settings findMany + */ + export type SettingsFindManyArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * Filter, which Settings to fetch. + */ + where?: SettingsWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Settings to fetch. + */ + orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for listing Settings. + */ + cursor?: SettingsWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Settings from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Settings. + */ + skip?: number + distinct?: SettingsScalarFieldEnum | SettingsScalarFieldEnum[] + } + + /** + * Settings create + */ + export type SettingsCreateArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * The data needed to create a Settings. + */ + data: XOR + } + + /** + * Settings createMany + */ + export type SettingsCreateManyArgs = { + /** + * The data used to create many Settings. + */ + data: SettingsCreateManyInput | SettingsCreateManyInput[] + } + + /** + * Settings createManyAndReturn + */ + export type SettingsCreateManyAndReturnArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelectCreateManyAndReturn | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * The data used to create many Settings. + */ + data: SettingsCreateManyInput | SettingsCreateManyInput[] + } + + /** + * Settings update + */ + export type SettingsUpdateArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * The data needed to update a Settings. + */ + data: XOR + /** + * Choose, which Settings to update. + */ + where: SettingsWhereUniqueInput + } + + /** + * Settings updateMany + */ + export type SettingsUpdateManyArgs = { + /** + * The data used to update Settings. + */ + data: XOR + /** + * Filter which Settings to update + */ + where?: SettingsWhereInput + /** + * Limit how many Settings to update. + */ + limit?: number + } + + /** + * Settings updateManyAndReturn + */ + export type SettingsUpdateManyAndReturnArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelectUpdateManyAndReturn | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * The data used to update Settings. + */ + data: XOR + /** + * Filter which Settings to update + */ + where?: SettingsWhereInput + /** + * Limit how many Settings to update. + */ + limit?: number + } + + /** + * Settings upsert + */ + export type SettingsUpsertArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * The filter to search for the Settings to update in case it exists. + */ + where: SettingsWhereUniqueInput + /** + * In case the Settings found by the `where` argument doesn't exist, create a new Settings with this data. + */ + create: XOR + /** + * In case the Settings was found with the provided `where` argument, update it with this data. + */ + update: XOR + } + + /** + * Settings delete + */ + export type SettingsDeleteArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + /** + * Filter which Settings to delete. + */ + where: SettingsWhereUniqueInput + } + + /** + * Settings deleteMany + */ + export type SettingsDeleteManyArgs = { + /** + * Filter which Settings to delete + */ + where?: SettingsWhereInput + /** + * Limit how many Settings to delete. + */ + limit?: number + } + + /** + * Settings without action + */ + export type SettingsDefaultArgs = { + /** + * Select specific fields to fetch from the Settings + */ + select?: SettingsSelect | null + /** + * Omit specific fields from the Settings + */ + omit?: SettingsOmit | null + } + + + /** + * Model Queue + */ + + export type AggregateQueue = { + _count: QueueCountAggregateOutputType | null + _avg: QueueAvgAggregateOutputType | null + _sum: QueueSumAggregateOutputType | null + _min: QueueMinAggregateOutputType | null + _max: QueueMaxAggregateOutputType | null + } + + export type QueueAvgAggregateOutputType = { + id: number | null + } + + export type QueueSumAggregateOutputType = { + id: number | null + } + + export type QueueMinAggregateOutputType = { + id: number | null + gpu_ids: string | null + is_running: boolean | null + } + + export type QueueMaxAggregateOutputType = { + id: number | null + gpu_ids: string | null + is_running: boolean | null + } + + export type QueueCountAggregateOutputType = { + id: number + gpu_ids: number + is_running: number + _all: number + } + + + export type QueueAvgAggregateInputType = { + id?: true + } + + export type QueueSumAggregateInputType = { + id?: true + } + + export type QueueMinAggregateInputType = { + id?: true + gpu_ids?: true + is_running?: true + } + + export type QueueMaxAggregateInputType = { + id?: true + gpu_ids?: true + is_running?: true + } + + export type QueueCountAggregateInputType = { + id?: true + gpu_ids?: true + is_running?: true + _all?: true + } + + export type QueueAggregateArgs = { + /** + * Filter which Queue to aggregate. + */ + where?: QueueWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Queues to fetch. + */ + orderBy?: QueueOrderByWithRelationInput | QueueOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the start position + */ + cursor?: QueueWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Queues from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Queues. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Count returned Queues + **/ + _count?: true | QueueCountAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to average + **/ + _avg?: QueueAvgAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to sum + **/ + _sum?: QueueSumAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to find the minimum value + **/ + _min?: QueueMinAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to find the maximum value + **/ + _max?: QueueMaxAggregateInputType + } + + export type GetQueueAggregateType = { + [P in keyof T & keyof AggregateQueue]: P extends '_count' | 'count' + ? T[P] extends true + ? number + : GetScalarType + : GetScalarType + } + + + + + export type QueueGroupByArgs = { + where?: QueueWhereInput + orderBy?: QueueOrderByWithAggregationInput | QueueOrderByWithAggregationInput[] + by: QueueScalarFieldEnum[] | QueueScalarFieldEnum + having?: QueueScalarWhereWithAggregatesInput + take?: number + skip?: number + _count?: QueueCountAggregateInputType | true + _avg?: QueueAvgAggregateInputType + _sum?: QueueSumAggregateInputType + _min?: QueueMinAggregateInputType + _max?: QueueMaxAggregateInputType + } + + export type QueueGroupByOutputType = { + id: number + gpu_ids: string + is_running: boolean + _count: QueueCountAggregateOutputType | null + _avg: QueueAvgAggregateOutputType | null + _sum: QueueSumAggregateOutputType | null + _min: QueueMinAggregateOutputType | null + _max: QueueMaxAggregateOutputType | null + } + + type GetQueueGroupByPayload = Prisma.PrismaPromise< + Array< + PickEnumerable & + { + [P in ((keyof T) & (keyof QueueGroupByOutputType))]: P extends '_count' + ? T[P] extends boolean + ? number + : GetScalarType + : GetScalarType + } + > + > + + + export type QueueSelect = $Extensions.GetSelect<{ + id?: boolean + gpu_ids?: boolean + is_running?: boolean + }, ExtArgs["result"]["queue"]> + + export type QueueSelectCreateManyAndReturn = $Extensions.GetSelect<{ + id?: boolean + gpu_ids?: boolean + is_running?: boolean + }, ExtArgs["result"]["queue"]> + + export type QueueSelectUpdateManyAndReturn = $Extensions.GetSelect<{ + id?: boolean + gpu_ids?: boolean + is_running?: boolean + }, ExtArgs["result"]["queue"]> + + export type QueueSelectScalar = { + id?: boolean + gpu_ids?: boolean + is_running?: boolean + } + + export type QueueOmit = $Extensions.GetOmit<"id" | "gpu_ids" | "is_running", ExtArgs["result"]["queue"]> + + export type $QueuePayload = { + name: "Queue" + objects: {} + scalars: $Extensions.GetPayloadResult<{ + id: number + gpu_ids: string + is_running: boolean + }, ExtArgs["result"]["queue"]> + composites: {} + } + + type QueueGetPayload = $Result.GetResult + + type QueueCountArgs = + Omit & { + select?: QueueCountAggregateInputType | true + } + + export interface QueueDelegate { + [K: symbol]: { types: Prisma.TypeMap['model']['Queue'], meta: { name: 'Queue' } } + /** + * Find zero or one Queue that matches the filter. + * @param {QueueFindUniqueArgs} args - Arguments to find a Queue + * @example + * // Get one Queue + * const queue = await prisma.queue.findUnique({ + * where: { + * // ... provide filter here + * } + * }) + */ + findUnique(args: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "findUnique", ClientOptions> | null, null, ExtArgs, ClientOptions> + + /** + * Find one Queue that matches the filter or throw an error with `error.code='P2025'` + * if no matches were found. + * @param {QueueFindUniqueOrThrowArgs} args - Arguments to find a Queue + * @example + * // Get one Queue + * const queue = await prisma.queue.findUniqueOrThrow({ + * where: { + * // ... provide filter here + * } + * }) + */ + findUniqueOrThrow(args: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "findUniqueOrThrow", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Find the first Queue 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 {QueueFindFirstArgs} args - Arguments to find a Queue + * @example + * // Get one Queue + * const queue = await prisma.queue.findFirst({ + * where: { + * // ... provide filter here + * } + * }) + */ + findFirst(args?: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "findFirst", ClientOptions> | null, null, ExtArgs, ClientOptions> + + /** + * Find the first Queue 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 {QueueFindFirstOrThrowArgs} args - Arguments to find a Queue + * @example + * // Get one Queue + * const queue = await prisma.queue.findFirstOrThrow({ + * where: { + * // ... provide filter here + * } + * }) + */ + findFirstOrThrow(args?: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "findFirstOrThrow", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Find zero or more Queues 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 {QueueFindManyArgs} args - Arguments to filter and select certain fields only. + * @example + * // Get all Queues + * const queues = await prisma.queue.findMany() + * + * // Get first 10 Queues + * const queues = await prisma.queue.findMany({ take: 10 }) + * + * // Only select the `id` + * const queueWithIdOnly = await prisma.queue.findMany({ select: { id: true } }) + * + */ + findMany(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "findMany", ClientOptions>> + + /** + * Create a Queue. + * @param {QueueCreateArgs} args - Arguments to create a Queue. + * @example + * // Create one Queue + * const Queue = await prisma.queue.create({ + * data: { + * // ... data to create a Queue + * } + * }) + * + */ + create(args: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "create", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Create many Queues. + * @param {QueueCreateManyArgs} args - Arguments to create many Queues. + * @example + * // Create many Queues + * const queue = await prisma.queue.createMany({ + * data: [ + * // ... provide data here + * ] + * }) + * + */ + createMany(args?: SelectSubset>): Prisma.PrismaPromise + + /** + * Create many Queues and returns the data saved in the database. + * @param {QueueCreateManyAndReturnArgs} args - Arguments to create many Queues. + * @example + * // Create many Queues + * const queue = await prisma.queue.createManyAndReturn({ + * data: [ + * // ... provide data here + * ] + * }) + * + * // Create many Queues and only return the `id` + * const queueWithIdOnly = await prisma.queue.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(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "createManyAndReturn", ClientOptions>> + + /** + * Delete a Queue. + * @param {QueueDeleteArgs} args - Arguments to delete one Queue. + * @example + * // Delete one Queue + * const Queue = await prisma.queue.delete({ + * where: { + * // ... filter to delete one Queue + * } + * }) + * + */ + delete(args: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "delete", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Update one Queue. + * @param {QueueUpdateArgs} args - Arguments to update one Queue. + * @example + * // Update one Queue + * const queue = await prisma.queue.update({ + * where: { + * // ... provide filter here + * }, + * data: { + * // ... provide data here + * } + * }) + * + */ + update(args: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "update", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Delete zero or more Queues. + * @param {QueueDeleteManyArgs} args - Arguments to filter Queues to delete. + * @example + * // Delete a few Queues + * const { count } = await prisma.queue.deleteMany({ + * where: { + * // ... provide filter here + * } + * }) + * + */ + deleteMany(args?: SelectSubset>): Prisma.PrismaPromise + + /** + * Update zero or more Queues. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {QueueUpdateManyArgs} args - Arguments to update one or more rows. + * @example + * // Update many Queues + * const queue = await prisma.queue.updateMany({ + * where: { + * // ... provide filter here + * }, + * data: { + * // ... provide data here + * } + * }) + * + */ + updateMany(args: SelectSubset>): Prisma.PrismaPromise + + /** + * Update zero or more Queues and returns the data updated in the database. + * @param {QueueUpdateManyAndReturnArgs} args - Arguments to update many Queues. + * @example + * // Update many Queues + * const queue = await prisma.queue.updateManyAndReturn({ + * where: { + * // ... provide filter here + * }, + * data: [ + * // ... provide data here + * ] + * }) + * + * // Update zero or more Queues and only return the `id` + * const queueWithIdOnly = await prisma.queue.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(args: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "updateManyAndReturn", ClientOptions>> + + /** + * Create or update one Queue. + * @param {QueueUpsertArgs} args - Arguments to update or create a Queue. + * @example + * // Update or create a Queue + * const queue = await prisma.queue.upsert({ + * create: { + * // ... data to create a Queue + * }, + * update: { + * // ... in case it already exists, update + * }, + * where: { + * // ... the filter for the Queue we want to update + * } + * }) + */ + upsert(args: SelectSubset>): Prisma__QueueClient<$Result.GetResult, T, "upsert", ClientOptions>, never, ExtArgs, ClientOptions> + + + /** + * Count the number of Queues. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {QueueCountArgs} args - Arguments to filter Queues to count. + * @example + * // Count the number of Queues + * const count = await prisma.queue.count({ + * where: { + * // ... the filter for the Queues we want to count + * } + * }) + **/ + count( + args?: Subset, + ): Prisma.PrismaPromise< + T extends $Utils.Record<'select', any> + ? T['select'] extends true + ? number + : GetScalarType + : number + > + + /** + * Allows you to perform aggregations operations on a Queue. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {QueueAggregateArgs} 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(args: Subset): Prisma.PrismaPromise> + + /** + * Group by Queue. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {QueueGroupByArgs} args - Group by arguments. + * @example + * // Group by city, order by createdAt, get count + * const result = await prisma.user.groupBy({ + * by: ['city', 'createdAt'], + * orderBy: { + * createdAt: true + * }, + * _count: { + * _all: true + * }, + * }) + * + **/ + groupBy< + T extends QueueGroupByArgs, + HasSelectOrTake extends Or< + Extends<'skip', Keys>, + Extends<'take', Keys> + >, + OrderByArg extends True extends HasSelectOrTake + ? { orderBy: QueueGroupByArgs['orderBy'] } + : { orderBy?: QueueGroupByArgs['orderBy'] }, + OrderFields extends ExcludeUnderscoreKeys>>, + ByFields extends MaybeTupleToUnion, + ByValid extends Has, + HavingFields extends GetHavingFields, + HavingValid extends Has, + ByEmpty extends T['by'] extends never[] ? True : False, + InputErrors extends ByEmpty extends True + ? `Error: "by" must not be empty.` + : HavingValid extends False + ? { + [P in HavingFields]: P extends ByFields + ? never + : P extends string + ? `Error: Field "${P}" used in "having" needs to be provided in "by".` + : [ + Error, + 'Field ', + P, + ` in "having" needs to be provided in "by"`, + ] + }[HavingFields] + : 'take' extends Keys + ? 'orderBy' extends Keys + ? 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 + ? 'orderBy' extends Keys + ? 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 & InputErrors): {} extends InputErrors ? GetQueueGroupByPayload : Prisma.PrismaPromise + /** + * Fields of the Queue model + */ + readonly fields: QueueFieldRefs; + } + + /** + * The delegate class that acts as a "Promise-like" for Queue. + * 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__QueueClient extends Prisma.PrismaPromise { + 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(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): $Utils.JsPromise + /** + * 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(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): $Utils.JsPromise + /** + * 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 + } + + + + + /** + * Fields of the Queue model + */ + interface QueueFieldRefs { + readonly id: FieldRef<"Queue", 'Int'> + readonly gpu_ids: FieldRef<"Queue", 'String'> + readonly is_running: FieldRef<"Queue", 'Boolean'> + } + + + // Custom InputTypes + /** + * Queue findUnique + */ + export type QueueFindUniqueArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * Filter, which Queue to fetch. + */ + where: QueueWhereUniqueInput + } + + /** + * Queue findUniqueOrThrow + */ + export type QueueFindUniqueOrThrowArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * Filter, which Queue to fetch. + */ + where: QueueWhereUniqueInput + } + + /** + * Queue findFirst + */ + export type QueueFindFirstArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * Filter, which Queue to fetch. + */ + where?: QueueWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Queues to fetch. + */ + orderBy?: QueueOrderByWithRelationInput | QueueOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for searching for Queues. + */ + cursor?: QueueWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Queues from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Queues. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} + * + * Filter by unique combinations of Queues. + */ + distinct?: QueueScalarFieldEnum | QueueScalarFieldEnum[] + } + + /** + * Queue findFirstOrThrow + */ + export type QueueFindFirstOrThrowArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * Filter, which Queue to fetch. + */ + where?: QueueWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Queues to fetch. + */ + orderBy?: QueueOrderByWithRelationInput | QueueOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for searching for Queues. + */ + cursor?: QueueWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Queues from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Queues. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} + * + * Filter by unique combinations of Queues. + */ + distinct?: QueueScalarFieldEnum | QueueScalarFieldEnum[] + } + + /** + * Queue findMany + */ + export type QueueFindManyArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * Filter, which Queues to fetch. + */ + where?: QueueWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Queues to fetch. + */ + orderBy?: QueueOrderByWithRelationInput | QueueOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for listing Queues. + */ + cursor?: QueueWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Queues from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Queues. + */ + skip?: number + distinct?: QueueScalarFieldEnum | QueueScalarFieldEnum[] + } + + /** + * Queue create + */ + export type QueueCreateArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * The data needed to create a Queue. + */ + data: XOR + } + + /** + * Queue createMany + */ + export type QueueCreateManyArgs = { + /** + * The data used to create many Queues. + */ + data: QueueCreateManyInput | QueueCreateManyInput[] + } + + /** + * Queue createManyAndReturn + */ + export type QueueCreateManyAndReturnArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelectCreateManyAndReturn | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * The data used to create many Queues. + */ + data: QueueCreateManyInput | QueueCreateManyInput[] + } + + /** + * Queue update + */ + export type QueueUpdateArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * The data needed to update a Queue. + */ + data: XOR + /** + * Choose, which Queue to update. + */ + where: QueueWhereUniqueInput + } + + /** + * Queue updateMany + */ + export type QueueUpdateManyArgs = { + /** + * The data used to update Queues. + */ + data: XOR + /** + * Filter which Queues to update + */ + where?: QueueWhereInput + /** + * Limit how many Queues to update. + */ + limit?: number + } + + /** + * Queue updateManyAndReturn + */ + export type QueueUpdateManyAndReturnArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelectUpdateManyAndReturn | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * The data used to update Queues. + */ + data: XOR + /** + * Filter which Queues to update + */ + where?: QueueWhereInput + /** + * Limit how many Queues to update. + */ + limit?: number + } + + /** + * Queue upsert + */ + export type QueueUpsertArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * The filter to search for the Queue to update in case it exists. + */ + where: QueueWhereUniqueInput + /** + * In case the Queue found by the `where` argument doesn't exist, create a new Queue with this data. + */ + create: XOR + /** + * In case the Queue was found with the provided `where` argument, update it with this data. + */ + update: XOR + } + + /** + * Queue delete + */ + export type QueueDeleteArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + /** + * Filter which Queue to delete. + */ + where: QueueWhereUniqueInput + } + + /** + * Queue deleteMany + */ + export type QueueDeleteManyArgs = { + /** + * Filter which Queues to delete + */ + where?: QueueWhereInput + /** + * Limit how many Queues to delete. + */ + limit?: number + } + + /** + * Queue without action + */ + export type QueueDefaultArgs = { + /** + * Select specific fields to fetch from the Queue + */ + select?: QueueSelect | null + /** + * Omit specific fields from the Queue + */ + omit?: QueueOmit | null + } + + + /** + * Model Job + */ + + export type AggregateJob = { + _count: JobCountAggregateOutputType | null + _avg: JobAvgAggregateOutputType | null + _sum: JobSumAggregateOutputType | null + _min: JobMinAggregateOutputType | null + _max: JobMaxAggregateOutputType | null + } + + export type JobAvgAggregateOutputType = { + step: number | null + queue_position: number | null + pid: number | null + } + + export type JobSumAggregateOutputType = { + step: number | null + queue_position: number | null + pid: number | null + } + + export type JobMinAggregateOutputType = { + id: string | null + name: string | null + gpu_ids: string | null + job_config: string | null + created_at: Date | null + updated_at: Date | null + status: string | null + stop: boolean | null + return_to_queue: boolean | null + step: number | null + info: string | null + speed_string: string | null + queue_position: number | null + pid: number | null + job_type: string | null + job_ref: string | null + } + + export type JobMaxAggregateOutputType = { + id: string | null + name: string | null + gpu_ids: string | null + job_config: string | null + created_at: Date | null + updated_at: Date | null + status: string | null + stop: boolean | null + return_to_queue: boolean | null + step: number | null + info: string | null + speed_string: string | null + queue_position: number | null + pid: number | null + job_type: string | null + job_ref: string | null + } + + export type JobCountAggregateOutputType = { + id: number + name: number + gpu_ids: number + job_config: number + created_at: number + updated_at: number + status: number + stop: number + return_to_queue: number + step: number + info: number + speed_string: number + queue_position: number + pid: number + job_type: number + job_ref: number + _all: number + } + + + export type JobAvgAggregateInputType = { + step?: true + queue_position?: true + pid?: true + } + + export type JobSumAggregateInputType = { + step?: true + queue_position?: true + pid?: true + } + + export type JobMinAggregateInputType = { + id?: true + name?: true + gpu_ids?: true + job_config?: true + created_at?: true + updated_at?: true + status?: true + stop?: true + return_to_queue?: true + step?: true + info?: true + speed_string?: true + queue_position?: true + pid?: true + job_type?: true + job_ref?: true + } + + export type JobMaxAggregateInputType = { + id?: true + name?: true + gpu_ids?: true + job_config?: true + created_at?: true + updated_at?: true + status?: true + stop?: true + return_to_queue?: true + step?: true + info?: true + speed_string?: true + queue_position?: true + pid?: true + job_type?: true + job_ref?: true + } + + export type JobCountAggregateInputType = { + id?: true + name?: true + gpu_ids?: true + job_config?: true + created_at?: true + updated_at?: true + status?: true + stop?: true + return_to_queue?: true + step?: true + info?: true + speed_string?: true + queue_position?: true + pid?: true + job_type?: true + job_ref?: true + _all?: true + } + + export type JobAggregateArgs = { + /** + * Filter which Job to aggregate. + */ + where?: JobWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Jobs to fetch. + */ + orderBy?: JobOrderByWithRelationInput | JobOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the start position + */ + cursor?: JobWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Jobs from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Jobs. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Count returned Jobs + **/ + _count?: true | JobCountAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to average + **/ + _avg?: JobAvgAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to sum + **/ + _sum?: JobSumAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to find the minimum value + **/ + _min?: JobMinAggregateInputType + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} + * + * Select which fields to find the maximum value + **/ + _max?: JobMaxAggregateInputType + } + + export type GetJobAggregateType = { + [P in keyof T & keyof AggregateJob]: P extends '_count' | 'count' + ? T[P] extends true + ? number + : GetScalarType + : GetScalarType + } + + + + + export type JobGroupByArgs = { + where?: JobWhereInput + orderBy?: JobOrderByWithAggregationInput | JobOrderByWithAggregationInput[] + by: JobScalarFieldEnum[] | JobScalarFieldEnum + having?: JobScalarWhereWithAggregatesInput + take?: number + skip?: number + _count?: JobCountAggregateInputType | true + _avg?: JobAvgAggregateInputType + _sum?: JobSumAggregateInputType + _min?: JobMinAggregateInputType + _max?: JobMaxAggregateInputType + } + + export type JobGroupByOutputType = { + id: string + name: string + gpu_ids: string + job_config: string + created_at: Date + updated_at: Date + status: string + stop: boolean + return_to_queue: boolean + step: number + info: string + speed_string: string + queue_position: number + pid: number | null + job_type: string + job_ref: string | null + _count: JobCountAggregateOutputType | null + _avg: JobAvgAggregateOutputType | null + _sum: JobSumAggregateOutputType | null + _min: JobMinAggregateOutputType | null + _max: JobMaxAggregateOutputType | null + } + + type GetJobGroupByPayload = Prisma.PrismaPromise< + Array< + PickEnumerable & + { + [P in ((keyof T) & (keyof JobGroupByOutputType))]: P extends '_count' + ? T[P] extends boolean + ? number + : GetScalarType + : GetScalarType + } + > + > + + + export type JobSelect = $Extensions.GetSelect<{ + id?: boolean + name?: boolean + gpu_ids?: boolean + job_config?: boolean + created_at?: boolean + updated_at?: boolean + status?: boolean + stop?: boolean + return_to_queue?: boolean + step?: boolean + info?: boolean + speed_string?: boolean + queue_position?: boolean + pid?: boolean + job_type?: boolean + job_ref?: boolean + }, ExtArgs["result"]["job"]> + + export type JobSelectCreateManyAndReturn = $Extensions.GetSelect<{ + id?: boolean + name?: boolean + gpu_ids?: boolean + job_config?: boolean + created_at?: boolean + updated_at?: boolean + status?: boolean + stop?: boolean + return_to_queue?: boolean + step?: boolean + info?: boolean + speed_string?: boolean + queue_position?: boolean + pid?: boolean + job_type?: boolean + job_ref?: boolean + }, ExtArgs["result"]["job"]> + + export type JobSelectUpdateManyAndReturn = $Extensions.GetSelect<{ + id?: boolean + name?: boolean + gpu_ids?: boolean + job_config?: boolean + created_at?: boolean + updated_at?: boolean + status?: boolean + stop?: boolean + return_to_queue?: boolean + step?: boolean + info?: boolean + speed_string?: boolean + queue_position?: boolean + pid?: boolean + job_type?: boolean + job_ref?: boolean + }, ExtArgs["result"]["job"]> + + export type JobSelectScalar = { + id?: boolean + name?: boolean + gpu_ids?: boolean + job_config?: boolean + created_at?: boolean + updated_at?: boolean + status?: boolean + stop?: boolean + return_to_queue?: boolean + step?: boolean + info?: boolean + speed_string?: boolean + queue_position?: boolean + pid?: boolean + job_type?: boolean + job_ref?: boolean + } + + export type JobOmit = $Extensions.GetOmit<"id" | "name" | "gpu_ids" | "job_config" | "created_at" | "updated_at" | "status" | "stop" | "return_to_queue" | "step" | "info" | "speed_string" | "queue_position" | "pid" | "job_type" | "job_ref", ExtArgs["result"]["job"]> + + export type $JobPayload = { + name: "Job" + objects: {} + scalars: $Extensions.GetPayloadResult<{ + id: string + name: string + gpu_ids: string + job_config: string + created_at: Date + updated_at: Date + status: string + stop: boolean + return_to_queue: boolean + step: number + info: string + speed_string: string + queue_position: number + pid: number | null + job_type: string + job_ref: string | null + }, ExtArgs["result"]["job"]> + composites: {} + } + + type JobGetPayload = $Result.GetResult + + type JobCountArgs = + Omit & { + select?: JobCountAggregateInputType | true + } + + export interface JobDelegate { + [K: symbol]: { types: Prisma.TypeMap['model']['Job'], meta: { name: 'Job' } } + /** + * Find zero or one Job that matches the filter. + * @param {JobFindUniqueArgs} args - Arguments to find a Job + * @example + * // Get one Job + * const job = await prisma.job.findUnique({ + * where: { + * // ... provide filter here + * } + * }) + */ + findUnique(args: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "findUnique", ClientOptions> | null, null, ExtArgs, ClientOptions> + + /** + * Find one Job that matches the filter or throw an error with `error.code='P2025'` + * if no matches were found. + * @param {JobFindUniqueOrThrowArgs} args - Arguments to find a Job + * @example + * // Get one Job + * const job = await prisma.job.findUniqueOrThrow({ + * where: { + * // ... provide filter here + * } + * }) + */ + findUniqueOrThrow(args: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "findUniqueOrThrow", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Find the first Job 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 {JobFindFirstArgs} args - Arguments to find a Job + * @example + * // Get one Job + * const job = await prisma.job.findFirst({ + * where: { + * // ... provide filter here + * } + * }) + */ + findFirst(args?: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "findFirst", ClientOptions> | null, null, ExtArgs, ClientOptions> + + /** + * Find the first Job 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 {JobFindFirstOrThrowArgs} args - Arguments to find a Job + * @example + * // Get one Job + * const job = await prisma.job.findFirstOrThrow({ + * where: { + * // ... provide filter here + * } + * }) + */ + findFirstOrThrow(args?: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "findFirstOrThrow", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Find zero or more Jobs 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 {JobFindManyArgs} args - Arguments to filter and select certain fields only. + * @example + * // Get all Jobs + * const jobs = await prisma.job.findMany() + * + * // Get first 10 Jobs + * const jobs = await prisma.job.findMany({ take: 10 }) + * + * // Only select the `id` + * const jobWithIdOnly = await prisma.job.findMany({ select: { id: true } }) + * + */ + findMany(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "findMany", ClientOptions>> + + /** + * Create a Job. + * @param {JobCreateArgs} args - Arguments to create a Job. + * @example + * // Create one Job + * const Job = await prisma.job.create({ + * data: { + * // ... data to create a Job + * } + * }) + * + */ + create(args: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "create", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Create many Jobs. + * @param {JobCreateManyArgs} args - Arguments to create many Jobs. + * @example + * // Create many Jobs + * const job = await prisma.job.createMany({ + * data: [ + * // ... provide data here + * ] + * }) + * + */ + createMany(args?: SelectSubset>): Prisma.PrismaPromise + + /** + * Create many Jobs and returns the data saved in the database. + * @param {JobCreateManyAndReturnArgs} args - Arguments to create many Jobs. + * @example + * // Create many Jobs + * const job = await prisma.job.createManyAndReturn({ + * data: [ + * // ... provide data here + * ] + * }) + * + * // Create many Jobs and only return the `id` + * const jobWithIdOnly = await prisma.job.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(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "createManyAndReturn", ClientOptions>> + + /** + * Delete a Job. + * @param {JobDeleteArgs} args - Arguments to delete one Job. + * @example + * // Delete one Job + * const Job = await prisma.job.delete({ + * where: { + * // ... filter to delete one Job + * } + * }) + * + */ + delete(args: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "delete", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Update one Job. + * @param {JobUpdateArgs} args - Arguments to update one Job. + * @example + * // Update one Job + * const job = await prisma.job.update({ + * where: { + * // ... provide filter here + * }, + * data: { + * // ... provide data here + * } + * }) + * + */ + update(args: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "update", ClientOptions>, never, ExtArgs, ClientOptions> + + /** + * Delete zero or more Jobs. + * @param {JobDeleteManyArgs} args - Arguments to filter Jobs to delete. + * @example + * // Delete a few Jobs + * const { count } = await prisma.job.deleteMany({ + * where: { + * // ... provide filter here + * } + * }) + * + */ + deleteMany(args?: SelectSubset>): Prisma.PrismaPromise + + /** + * Update zero or more Jobs. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {JobUpdateManyArgs} args - Arguments to update one or more rows. + * @example + * // Update many Jobs + * const job = await prisma.job.updateMany({ + * where: { + * // ... provide filter here + * }, + * data: { + * // ... provide data here + * } + * }) + * + */ + updateMany(args: SelectSubset>): Prisma.PrismaPromise + + /** + * Update zero or more Jobs and returns the data updated in the database. + * @param {JobUpdateManyAndReturnArgs} args - Arguments to update many Jobs. + * @example + * // Update many Jobs + * const job = await prisma.job.updateManyAndReturn({ + * where: { + * // ... provide filter here + * }, + * data: [ + * // ... provide data here + * ] + * }) + * + * // Update zero or more Jobs and only return the `id` + * const jobWithIdOnly = await prisma.job.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(args: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "updateManyAndReturn", ClientOptions>> + + /** + * Create or update one Job. + * @param {JobUpsertArgs} args - Arguments to update or create a Job. + * @example + * // Update or create a Job + * const job = await prisma.job.upsert({ + * create: { + * // ... data to create a Job + * }, + * update: { + * // ... in case it already exists, update + * }, + * where: { + * // ... the filter for the Job we want to update + * } + * }) + */ + upsert(args: SelectSubset>): Prisma__JobClient<$Result.GetResult, T, "upsert", ClientOptions>, never, ExtArgs, ClientOptions> + + + /** + * Count the number of Jobs. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {JobCountArgs} args - Arguments to filter Jobs to count. + * @example + * // Count the number of Jobs + * const count = await prisma.job.count({ + * where: { + * // ... the filter for the Jobs we want to count + * } + * }) + **/ + count( + args?: Subset, + ): Prisma.PrismaPromise< + T extends $Utils.Record<'select', any> + ? T['select'] extends true + ? number + : GetScalarType + : number + > + + /** + * Allows you to perform aggregations operations on a Job. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {JobAggregateArgs} 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(args: Subset): Prisma.PrismaPromise> + + /** + * Group by Job. + * Note, that providing `undefined` is treated as the value not being there. + * Read more here: https://pris.ly/d/null-undefined + * @param {JobGroupByArgs} args - Group by arguments. + * @example + * // Group by city, order by createdAt, get count + * const result = await prisma.user.groupBy({ + * by: ['city', 'createdAt'], + * orderBy: { + * createdAt: true + * }, + * _count: { + * _all: true + * }, + * }) + * + **/ + groupBy< + T extends JobGroupByArgs, + HasSelectOrTake extends Or< + Extends<'skip', Keys>, + Extends<'take', Keys> + >, + OrderByArg extends True extends HasSelectOrTake + ? { orderBy: JobGroupByArgs['orderBy'] } + : { orderBy?: JobGroupByArgs['orderBy'] }, + OrderFields extends ExcludeUnderscoreKeys>>, + ByFields extends MaybeTupleToUnion, + ByValid extends Has, + HavingFields extends GetHavingFields, + HavingValid extends Has, + ByEmpty extends T['by'] extends never[] ? True : False, + InputErrors extends ByEmpty extends True + ? `Error: "by" must not be empty.` + : HavingValid extends False + ? { + [P in HavingFields]: P extends ByFields + ? never + : P extends string + ? `Error: Field "${P}" used in "having" needs to be provided in "by".` + : [ + Error, + 'Field ', + P, + ` in "having" needs to be provided in "by"`, + ] + }[HavingFields] + : 'take' extends Keys + ? 'orderBy' extends Keys + ? 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 + ? 'orderBy' extends Keys + ? 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 & InputErrors): {} extends InputErrors ? GetJobGroupByPayload : Prisma.PrismaPromise + /** + * Fields of the Job model + */ + readonly fields: JobFieldRefs; + } + + /** + * The delegate class that acts as a "Promise-like" for Job. + * 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__JobClient extends Prisma.PrismaPromise { + 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(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): $Utils.JsPromise + /** + * 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(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): $Utils.JsPromise + /** + * 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 + } + + + + + /** + * Fields of the Job model + */ + interface JobFieldRefs { + readonly id: FieldRef<"Job", 'String'> + readonly name: FieldRef<"Job", 'String'> + readonly gpu_ids: FieldRef<"Job", 'String'> + readonly job_config: FieldRef<"Job", 'String'> + readonly created_at: FieldRef<"Job", 'DateTime'> + readonly updated_at: FieldRef<"Job", 'DateTime'> + readonly status: FieldRef<"Job", 'String'> + readonly stop: FieldRef<"Job", 'Boolean'> + readonly return_to_queue: FieldRef<"Job", 'Boolean'> + readonly step: FieldRef<"Job", 'Int'> + readonly info: FieldRef<"Job", 'String'> + readonly speed_string: FieldRef<"Job", 'String'> + readonly queue_position: FieldRef<"Job", 'Int'> + readonly pid: FieldRef<"Job", 'Int'> + readonly job_type: FieldRef<"Job", 'String'> + readonly job_ref: FieldRef<"Job", 'String'> + } + + + // Custom InputTypes + /** + * Job findUnique + */ + export type JobFindUniqueArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * Filter, which Job to fetch. + */ + where: JobWhereUniqueInput + } + + /** + * Job findUniqueOrThrow + */ + export type JobFindUniqueOrThrowArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * Filter, which Job to fetch. + */ + where: JobWhereUniqueInput + } + + /** + * Job findFirst + */ + export type JobFindFirstArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * Filter, which Job to fetch. + */ + where?: JobWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Jobs to fetch. + */ + orderBy?: JobOrderByWithRelationInput | JobOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for searching for Jobs. + */ + cursor?: JobWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Jobs from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Jobs. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} + * + * Filter by unique combinations of Jobs. + */ + distinct?: JobScalarFieldEnum | JobScalarFieldEnum[] + } + + /** + * Job findFirstOrThrow + */ + export type JobFindFirstOrThrowArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * Filter, which Job to fetch. + */ + where?: JobWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Jobs to fetch. + */ + orderBy?: JobOrderByWithRelationInput | JobOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for searching for Jobs. + */ + cursor?: JobWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Jobs from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Jobs. + */ + skip?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} + * + * Filter by unique combinations of Jobs. + */ + distinct?: JobScalarFieldEnum | JobScalarFieldEnum[] + } + + /** + * Job findMany + */ + export type JobFindManyArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * Filter, which Jobs to fetch. + */ + where?: JobWhereInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} + * + * Determine the order of Jobs to fetch. + */ + orderBy?: JobOrderByWithRelationInput | JobOrderByWithRelationInput[] + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} + * + * Sets the position for listing Jobs. + */ + cursor?: JobWhereUniqueInput + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Take `±n` Jobs from the position of the cursor. + */ + take?: number + /** + * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} + * + * Skip the first `n` Jobs. + */ + skip?: number + distinct?: JobScalarFieldEnum | JobScalarFieldEnum[] + } + + /** + * Job create + */ + export type JobCreateArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * The data needed to create a Job. + */ + data: XOR + } + + /** + * Job createMany + */ + export type JobCreateManyArgs = { + /** + * The data used to create many Jobs. + */ + data: JobCreateManyInput | JobCreateManyInput[] + } + + /** + * Job createManyAndReturn + */ + export type JobCreateManyAndReturnArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelectCreateManyAndReturn | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * The data used to create many Jobs. + */ + data: JobCreateManyInput | JobCreateManyInput[] + } + + /** + * Job update + */ + export type JobUpdateArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * The data needed to update a Job. + */ + data: XOR + /** + * Choose, which Job to update. + */ + where: JobWhereUniqueInput + } + + /** + * Job updateMany + */ + export type JobUpdateManyArgs = { + /** + * The data used to update Jobs. + */ + data: XOR + /** + * Filter which Jobs to update + */ + where?: JobWhereInput + /** + * Limit how many Jobs to update. + */ + limit?: number + } + + /** + * Job updateManyAndReturn + */ + export type JobUpdateManyAndReturnArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelectUpdateManyAndReturn | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * The data used to update Jobs. + */ + data: XOR + /** + * Filter which Jobs to update + */ + where?: JobWhereInput + /** + * Limit how many Jobs to update. + */ + limit?: number + } + + /** + * Job upsert + */ + export type JobUpsertArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * The filter to search for the Job to update in case it exists. + */ + where: JobWhereUniqueInput + /** + * In case the Job found by the `where` argument doesn't exist, create a new Job with this data. + */ + create: XOR + /** + * In case the Job was found with the provided `where` argument, update it with this data. + */ + update: XOR + } + + /** + * Job delete + */ + export type JobDeleteArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + /** + * Filter which Job to delete. + */ + where: JobWhereUniqueInput + } + + /** + * Job deleteMany + */ + export type JobDeleteManyArgs = { + /** + * Filter which Jobs to delete + */ + where?: JobWhereInput + /** + * Limit how many Jobs to delete. + */ + limit?: number + } + + /** + * Job without action + */ + export type JobDefaultArgs = { + /** + * Select specific fields to fetch from the Job + */ + select?: JobSelect | null + /** + * Omit specific fields from the Job + */ + omit?: JobOmit | null + } + + + /** + * Enums + */ + + export const TransactionIsolationLevel: { + Serializable: 'Serializable' + }; + + export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel] + + + export const SettingsScalarFieldEnum: { + id: 'id', + key: 'key', + value: 'value' + }; + + export type SettingsScalarFieldEnum = (typeof SettingsScalarFieldEnum)[keyof typeof SettingsScalarFieldEnum] + + + export const QueueScalarFieldEnum: { + id: 'id', + gpu_ids: 'gpu_ids', + is_running: 'is_running' + }; + + export type QueueScalarFieldEnum = (typeof QueueScalarFieldEnum)[keyof typeof QueueScalarFieldEnum] + + + export const JobScalarFieldEnum: { + id: 'id', + name: 'name', + gpu_ids: 'gpu_ids', + job_config: 'job_config', + created_at: 'created_at', + updated_at: 'updated_at', + status: 'status', + stop: 'stop', + return_to_queue: 'return_to_queue', + step: 'step', + info: 'info', + speed_string: 'speed_string', + queue_position: 'queue_position', + pid: 'pid', + job_type: 'job_type', + job_ref: 'job_ref' + }; + + export type JobScalarFieldEnum = (typeof JobScalarFieldEnum)[keyof typeof JobScalarFieldEnum] + + + export const SortOrder: { + asc: 'asc', + desc: 'desc' + }; + + export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder] + + + export const NullsOrder: { + first: 'first', + last: 'last' + }; + + export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder] + + + /** + * Field references + */ + + + /** + * Reference to a field of type 'Int' + */ + export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'> + + + + /** + * Reference to a field of type 'String' + */ + export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'> + + + + /** + * Reference to a field of type 'Boolean' + */ + export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'> + + + + /** + * Reference to a field of type 'DateTime' + */ + export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'> + + + + /** + * Reference to a field of type 'Float' + */ + export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'> + + /** + * Deep Input Types + */ + + + export type SettingsWhereInput = { + AND?: SettingsWhereInput | SettingsWhereInput[] + OR?: SettingsWhereInput[] + NOT?: SettingsWhereInput | SettingsWhereInput[] + id?: IntFilter<"Settings"> | number + key?: StringFilter<"Settings"> | string + value?: StringFilter<"Settings"> | string + } + + export type SettingsOrderByWithRelationInput = { + id?: SortOrder + key?: SortOrder + value?: SortOrder + } + + export type SettingsWhereUniqueInput = Prisma.AtLeast<{ + id?: number + key?: string + AND?: SettingsWhereInput | SettingsWhereInput[] + OR?: SettingsWhereInput[] + NOT?: SettingsWhereInput | SettingsWhereInput[] + value?: StringFilter<"Settings"> | string + }, "id" | "key"> + + export type SettingsOrderByWithAggregationInput = { + id?: SortOrder + key?: SortOrder + value?: SortOrder + _count?: SettingsCountOrderByAggregateInput + _avg?: SettingsAvgOrderByAggregateInput + _max?: SettingsMaxOrderByAggregateInput + _min?: SettingsMinOrderByAggregateInput + _sum?: SettingsSumOrderByAggregateInput + } + + export type SettingsScalarWhereWithAggregatesInput = { + AND?: SettingsScalarWhereWithAggregatesInput | SettingsScalarWhereWithAggregatesInput[] + OR?: SettingsScalarWhereWithAggregatesInput[] + NOT?: SettingsScalarWhereWithAggregatesInput | SettingsScalarWhereWithAggregatesInput[] + id?: IntWithAggregatesFilter<"Settings"> | number + key?: StringWithAggregatesFilter<"Settings"> | string + value?: StringWithAggregatesFilter<"Settings"> | string + } + + export type QueueWhereInput = { + AND?: QueueWhereInput | QueueWhereInput[] + OR?: QueueWhereInput[] + NOT?: QueueWhereInput | QueueWhereInput[] + id?: IntFilter<"Queue"> | number + gpu_ids?: StringFilter<"Queue"> | string + is_running?: BoolFilter<"Queue"> | boolean + } + + export type QueueOrderByWithRelationInput = { + id?: SortOrder + gpu_ids?: SortOrder + is_running?: SortOrder + } + + export type QueueWhereUniqueInput = Prisma.AtLeast<{ + id?: number + gpu_ids?: string + AND?: QueueWhereInput | QueueWhereInput[] + OR?: QueueWhereInput[] + NOT?: QueueWhereInput | QueueWhereInput[] + is_running?: BoolFilter<"Queue"> | boolean + }, "id" | "gpu_ids"> + + export type QueueOrderByWithAggregationInput = { + id?: SortOrder + gpu_ids?: SortOrder + is_running?: SortOrder + _count?: QueueCountOrderByAggregateInput + _avg?: QueueAvgOrderByAggregateInput + _max?: QueueMaxOrderByAggregateInput + _min?: QueueMinOrderByAggregateInput + _sum?: QueueSumOrderByAggregateInput + } + + export type QueueScalarWhereWithAggregatesInput = { + AND?: QueueScalarWhereWithAggregatesInput | QueueScalarWhereWithAggregatesInput[] + OR?: QueueScalarWhereWithAggregatesInput[] + NOT?: QueueScalarWhereWithAggregatesInput | QueueScalarWhereWithAggregatesInput[] + id?: IntWithAggregatesFilter<"Queue"> | number + gpu_ids?: StringWithAggregatesFilter<"Queue"> | string + is_running?: BoolWithAggregatesFilter<"Queue"> | boolean + } + + export type JobWhereInput = { + AND?: JobWhereInput | JobWhereInput[] + OR?: JobWhereInput[] + NOT?: JobWhereInput | JobWhereInput[] + id?: StringFilter<"Job"> | string + name?: StringFilter<"Job"> | string + gpu_ids?: StringFilter<"Job"> | string + job_config?: StringFilter<"Job"> | string + created_at?: DateTimeFilter<"Job"> | Date | string + updated_at?: DateTimeFilter<"Job"> | Date | string + status?: StringFilter<"Job"> | string + stop?: BoolFilter<"Job"> | boolean + return_to_queue?: BoolFilter<"Job"> | boolean + step?: IntFilter<"Job"> | number + info?: StringFilter<"Job"> | string + speed_string?: StringFilter<"Job"> | string + queue_position?: IntFilter<"Job"> | number + pid?: IntNullableFilter<"Job"> | number | null + job_type?: StringFilter<"Job"> | string + job_ref?: StringNullableFilter<"Job"> | string | null + } + + export type JobOrderByWithRelationInput = { + id?: SortOrder + name?: SortOrder + gpu_ids?: SortOrder + job_config?: SortOrder + created_at?: SortOrder + updated_at?: SortOrder + status?: SortOrder + stop?: SortOrder + return_to_queue?: SortOrder + step?: SortOrder + info?: SortOrder + speed_string?: SortOrder + queue_position?: SortOrder + pid?: SortOrderInput | SortOrder + job_type?: SortOrder + job_ref?: SortOrderInput | SortOrder + } + + export type JobWhereUniqueInput = Prisma.AtLeast<{ + id?: string + name?: string + AND?: JobWhereInput | JobWhereInput[] + OR?: JobWhereInput[] + NOT?: JobWhereInput | JobWhereInput[] + gpu_ids?: StringFilter<"Job"> | string + job_config?: StringFilter<"Job"> | string + created_at?: DateTimeFilter<"Job"> | Date | string + updated_at?: DateTimeFilter<"Job"> | Date | string + status?: StringFilter<"Job"> | string + stop?: BoolFilter<"Job"> | boolean + return_to_queue?: BoolFilter<"Job"> | boolean + step?: IntFilter<"Job"> | number + info?: StringFilter<"Job"> | string + speed_string?: StringFilter<"Job"> | string + queue_position?: IntFilter<"Job"> | number + pid?: IntNullableFilter<"Job"> | number | null + job_type?: StringFilter<"Job"> | string + job_ref?: StringNullableFilter<"Job"> | string | null + }, "id" | "name"> + + export type JobOrderByWithAggregationInput = { + id?: SortOrder + name?: SortOrder + gpu_ids?: SortOrder + job_config?: SortOrder + created_at?: SortOrder + updated_at?: SortOrder + status?: SortOrder + stop?: SortOrder + return_to_queue?: SortOrder + step?: SortOrder + info?: SortOrder + speed_string?: SortOrder + queue_position?: SortOrder + pid?: SortOrderInput | SortOrder + job_type?: SortOrder + job_ref?: SortOrderInput | SortOrder + _count?: JobCountOrderByAggregateInput + _avg?: JobAvgOrderByAggregateInput + _max?: JobMaxOrderByAggregateInput + _min?: JobMinOrderByAggregateInput + _sum?: JobSumOrderByAggregateInput + } + + export type JobScalarWhereWithAggregatesInput = { + AND?: JobScalarWhereWithAggregatesInput | JobScalarWhereWithAggregatesInput[] + OR?: JobScalarWhereWithAggregatesInput[] + NOT?: JobScalarWhereWithAggregatesInput | JobScalarWhereWithAggregatesInput[] + id?: StringWithAggregatesFilter<"Job"> | string + name?: StringWithAggregatesFilter<"Job"> | string + gpu_ids?: StringWithAggregatesFilter<"Job"> | string + job_config?: StringWithAggregatesFilter<"Job"> | string + created_at?: DateTimeWithAggregatesFilter<"Job"> | Date | string + updated_at?: DateTimeWithAggregatesFilter<"Job"> | Date | string + status?: StringWithAggregatesFilter<"Job"> | string + stop?: BoolWithAggregatesFilter<"Job"> | boolean + return_to_queue?: BoolWithAggregatesFilter<"Job"> | boolean + step?: IntWithAggregatesFilter<"Job"> | number + info?: StringWithAggregatesFilter<"Job"> | string + speed_string?: StringWithAggregatesFilter<"Job"> | string + queue_position?: IntWithAggregatesFilter<"Job"> | number + pid?: IntNullableWithAggregatesFilter<"Job"> | number | null + job_type?: StringWithAggregatesFilter<"Job"> | string + job_ref?: StringNullableWithAggregatesFilter<"Job"> | string | null + } + + export type SettingsCreateInput = { + key: string + value: string + } + + export type SettingsUncheckedCreateInput = { + id?: number + key: string + value: string + } + + export type SettingsUpdateInput = { + key?: StringFieldUpdateOperationsInput | string + value?: StringFieldUpdateOperationsInput | string + } + + export type SettingsUncheckedUpdateInput = { + id?: IntFieldUpdateOperationsInput | number + key?: StringFieldUpdateOperationsInput | string + value?: StringFieldUpdateOperationsInput | string + } + + export type SettingsCreateManyInput = { + id?: number + key: string + value: string + } + + export type SettingsUpdateManyMutationInput = { + key?: StringFieldUpdateOperationsInput | string + value?: StringFieldUpdateOperationsInput | string + } + + export type SettingsUncheckedUpdateManyInput = { + id?: IntFieldUpdateOperationsInput | number + key?: StringFieldUpdateOperationsInput | string + value?: StringFieldUpdateOperationsInput | string + } + + export type QueueCreateInput = { + gpu_ids: string + is_running?: boolean + } + + export type QueueUncheckedCreateInput = { + id?: number + gpu_ids: string + is_running?: boolean + } + + export type QueueUpdateInput = { + gpu_ids?: StringFieldUpdateOperationsInput | string + is_running?: BoolFieldUpdateOperationsInput | boolean + } + + export type QueueUncheckedUpdateInput = { + id?: IntFieldUpdateOperationsInput | number + gpu_ids?: StringFieldUpdateOperationsInput | string + is_running?: BoolFieldUpdateOperationsInput | boolean + } + + export type QueueCreateManyInput = { + id?: number + gpu_ids: string + is_running?: boolean + } + + export type QueueUpdateManyMutationInput = { + gpu_ids?: StringFieldUpdateOperationsInput | string + is_running?: BoolFieldUpdateOperationsInput | boolean + } + + export type QueueUncheckedUpdateManyInput = { + id?: IntFieldUpdateOperationsInput | number + gpu_ids?: StringFieldUpdateOperationsInput | string + is_running?: BoolFieldUpdateOperationsInput | boolean + } + + export type JobCreateInput = { + id?: string + name: string + gpu_ids: string + job_config: string + created_at?: Date | string + updated_at?: Date | string + status?: string + stop?: boolean + return_to_queue?: boolean + step?: number + info?: string + speed_string?: string + queue_position?: number + pid?: number | null + job_type?: string + job_ref?: string | null + } + + export type JobUncheckedCreateInput = { + id?: string + name: string + gpu_ids: string + job_config: string + created_at?: Date | string + updated_at?: Date | string + status?: string + stop?: boolean + return_to_queue?: boolean + step?: number + info?: string + speed_string?: string + queue_position?: number + pid?: number | null + job_type?: string + job_ref?: string | null + } + + export type JobUpdateInput = { + id?: StringFieldUpdateOperationsInput | string + name?: StringFieldUpdateOperationsInput | string + gpu_ids?: StringFieldUpdateOperationsInput | string + job_config?: StringFieldUpdateOperationsInput | string + created_at?: DateTimeFieldUpdateOperationsInput | Date | string + updated_at?: DateTimeFieldUpdateOperationsInput | Date | string + status?: StringFieldUpdateOperationsInput | string + stop?: BoolFieldUpdateOperationsInput | boolean + return_to_queue?: BoolFieldUpdateOperationsInput | boolean + step?: IntFieldUpdateOperationsInput | number + info?: StringFieldUpdateOperationsInput | string + speed_string?: StringFieldUpdateOperationsInput | string + queue_position?: IntFieldUpdateOperationsInput | number + pid?: NullableIntFieldUpdateOperationsInput | number | null + job_type?: StringFieldUpdateOperationsInput | string + job_ref?: NullableStringFieldUpdateOperationsInput | string | null + } + + export type JobUncheckedUpdateInput = { + id?: StringFieldUpdateOperationsInput | string + name?: StringFieldUpdateOperationsInput | string + gpu_ids?: StringFieldUpdateOperationsInput | string + job_config?: StringFieldUpdateOperationsInput | string + created_at?: DateTimeFieldUpdateOperationsInput | Date | string + updated_at?: DateTimeFieldUpdateOperationsInput | Date | string + status?: StringFieldUpdateOperationsInput | string + stop?: BoolFieldUpdateOperationsInput | boolean + return_to_queue?: BoolFieldUpdateOperationsInput | boolean + step?: IntFieldUpdateOperationsInput | number + info?: StringFieldUpdateOperationsInput | string + speed_string?: StringFieldUpdateOperationsInput | string + queue_position?: IntFieldUpdateOperationsInput | number + pid?: NullableIntFieldUpdateOperationsInput | number | null + job_type?: StringFieldUpdateOperationsInput | string + job_ref?: NullableStringFieldUpdateOperationsInput | string | null + } + + export type JobCreateManyInput = { + id?: string + name: string + gpu_ids: string + job_config: string + created_at?: Date | string + updated_at?: Date | string + status?: string + stop?: boolean + return_to_queue?: boolean + step?: number + info?: string + speed_string?: string + queue_position?: number + pid?: number | null + job_type?: string + job_ref?: string | null + } + + export type JobUpdateManyMutationInput = { + id?: StringFieldUpdateOperationsInput | string + name?: StringFieldUpdateOperationsInput | string + gpu_ids?: StringFieldUpdateOperationsInput | string + job_config?: StringFieldUpdateOperationsInput | string + created_at?: DateTimeFieldUpdateOperationsInput | Date | string + updated_at?: DateTimeFieldUpdateOperationsInput | Date | string + status?: StringFieldUpdateOperationsInput | string + stop?: BoolFieldUpdateOperationsInput | boolean + return_to_queue?: BoolFieldUpdateOperationsInput | boolean + step?: IntFieldUpdateOperationsInput | number + info?: StringFieldUpdateOperationsInput | string + speed_string?: StringFieldUpdateOperationsInput | string + queue_position?: IntFieldUpdateOperationsInput | number + pid?: NullableIntFieldUpdateOperationsInput | number | null + job_type?: StringFieldUpdateOperationsInput | string + job_ref?: NullableStringFieldUpdateOperationsInput | string | null + } + + export type JobUncheckedUpdateManyInput = { + id?: StringFieldUpdateOperationsInput | string + name?: StringFieldUpdateOperationsInput | string + gpu_ids?: StringFieldUpdateOperationsInput | string + job_config?: StringFieldUpdateOperationsInput | string + created_at?: DateTimeFieldUpdateOperationsInput | Date | string + updated_at?: DateTimeFieldUpdateOperationsInput | Date | string + status?: StringFieldUpdateOperationsInput | string + stop?: BoolFieldUpdateOperationsInput | boolean + return_to_queue?: BoolFieldUpdateOperationsInput | boolean + step?: IntFieldUpdateOperationsInput | number + info?: StringFieldUpdateOperationsInput | string + speed_string?: StringFieldUpdateOperationsInput | string + queue_position?: IntFieldUpdateOperationsInput | number + pid?: NullableIntFieldUpdateOperationsInput | number | null + job_type?: StringFieldUpdateOperationsInput | string + job_ref?: NullableStringFieldUpdateOperationsInput | string | null + } + + export type IntFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> + in?: number[] + notIn?: number[] + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntFilter<$PrismaModel> | number + } + + export type StringFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> + in?: string[] + notIn?: string[] + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringFilter<$PrismaModel> | string + } + + export type SettingsCountOrderByAggregateInput = { + id?: SortOrder + key?: SortOrder + value?: SortOrder + } + + export type SettingsAvgOrderByAggregateInput = { + id?: SortOrder + } + + export type SettingsMaxOrderByAggregateInput = { + id?: SortOrder + key?: SortOrder + value?: SortOrder + } + + export type SettingsMinOrderByAggregateInput = { + id?: SortOrder + key?: SortOrder + value?: SortOrder + } + + export type SettingsSumOrderByAggregateInput = { + id?: SortOrder + } + + export type IntWithAggregatesFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> + in?: number[] + notIn?: number[] + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntWithAggregatesFilter<$PrismaModel> | number + _count?: NestedIntFilter<$PrismaModel> + _avg?: NestedFloatFilter<$PrismaModel> + _sum?: NestedIntFilter<$PrismaModel> + _min?: NestedIntFilter<$PrismaModel> + _max?: NestedIntFilter<$PrismaModel> + } + + export type StringWithAggregatesFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> + in?: string[] + notIn?: string[] + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringWithAggregatesFilter<$PrismaModel> | string + _count?: NestedIntFilter<$PrismaModel> + _min?: NestedStringFilter<$PrismaModel> + _max?: NestedStringFilter<$PrismaModel> + } + + export type BoolFilter<$PrismaModel = never> = { + equals?: boolean | BooleanFieldRefInput<$PrismaModel> + not?: NestedBoolFilter<$PrismaModel> | boolean + } + + export type QueueCountOrderByAggregateInput = { + id?: SortOrder + gpu_ids?: SortOrder + is_running?: SortOrder + } + + export type QueueAvgOrderByAggregateInput = { + id?: SortOrder + } + + export type QueueMaxOrderByAggregateInput = { + id?: SortOrder + gpu_ids?: SortOrder + is_running?: SortOrder + } + + export type QueueMinOrderByAggregateInput = { + id?: SortOrder + gpu_ids?: SortOrder + is_running?: SortOrder + } + + export type QueueSumOrderByAggregateInput = { + id?: SortOrder + } + + export type BoolWithAggregatesFilter<$PrismaModel = never> = { + equals?: boolean | BooleanFieldRefInput<$PrismaModel> + not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean + _count?: NestedIntFilter<$PrismaModel> + _min?: NestedBoolFilter<$PrismaModel> + _max?: NestedBoolFilter<$PrismaModel> + } + + export type DateTimeFilter<$PrismaModel = never> = { + equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> + in?: Date[] | string[] + notIn?: Date[] | string[] + lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + not?: NestedDateTimeFilter<$PrismaModel> | Date | string + } + + export type IntNullableFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> | null + in?: number[] | null + notIn?: number[] | null + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntNullableFilter<$PrismaModel> | number | null + } + + export type StringNullableFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> | null + in?: string[] | null + notIn?: string[] | null + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringNullableFilter<$PrismaModel> | string | null + } + + export type SortOrderInput = { + sort: SortOrder + nulls?: NullsOrder + } + + export type JobCountOrderByAggregateInput = { + id?: SortOrder + name?: SortOrder + gpu_ids?: SortOrder + job_config?: SortOrder + created_at?: SortOrder + updated_at?: SortOrder + status?: SortOrder + stop?: SortOrder + return_to_queue?: SortOrder + step?: SortOrder + info?: SortOrder + speed_string?: SortOrder + queue_position?: SortOrder + pid?: SortOrder + job_type?: SortOrder + job_ref?: SortOrder + } + + export type JobAvgOrderByAggregateInput = { + step?: SortOrder + queue_position?: SortOrder + pid?: SortOrder + } + + export type JobMaxOrderByAggregateInput = { + id?: SortOrder + name?: SortOrder + gpu_ids?: SortOrder + job_config?: SortOrder + created_at?: SortOrder + updated_at?: SortOrder + status?: SortOrder + stop?: SortOrder + return_to_queue?: SortOrder + step?: SortOrder + info?: SortOrder + speed_string?: SortOrder + queue_position?: SortOrder + pid?: SortOrder + job_type?: SortOrder + job_ref?: SortOrder + } + + export type JobMinOrderByAggregateInput = { + id?: SortOrder + name?: SortOrder + gpu_ids?: SortOrder + job_config?: SortOrder + created_at?: SortOrder + updated_at?: SortOrder + status?: SortOrder + stop?: SortOrder + return_to_queue?: SortOrder + step?: SortOrder + info?: SortOrder + speed_string?: SortOrder + queue_position?: SortOrder + pid?: SortOrder + job_type?: SortOrder + job_ref?: SortOrder + } + + export type JobSumOrderByAggregateInput = { + step?: SortOrder + queue_position?: SortOrder + pid?: SortOrder + } + + export type DateTimeWithAggregatesFilter<$PrismaModel = never> = { + equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> + in?: Date[] | string[] + notIn?: Date[] | string[] + lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string + _count?: NestedIntFilter<$PrismaModel> + _min?: NestedDateTimeFilter<$PrismaModel> + _max?: NestedDateTimeFilter<$PrismaModel> + } + + export type IntNullableWithAggregatesFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> | null + in?: number[] | null + notIn?: number[] | null + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null + _count?: NestedIntNullableFilter<$PrismaModel> + _avg?: NestedFloatNullableFilter<$PrismaModel> + _sum?: NestedIntNullableFilter<$PrismaModel> + _min?: NestedIntNullableFilter<$PrismaModel> + _max?: NestedIntNullableFilter<$PrismaModel> + } + + export type StringNullableWithAggregatesFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> | null + in?: string[] | null + notIn?: string[] | null + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null + _count?: NestedIntNullableFilter<$PrismaModel> + _min?: NestedStringNullableFilter<$PrismaModel> + _max?: NestedStringNullableFilter<$PrismaModel> + } + + export type StringFieldUpdateOperationsInput = { + set?: string + } + + export type IntFieldUpdateOperationsInput = { + set?: number + increment?: number + decrement?: number + multiply?: number + divide?: number + } + + export type BoolFieldUpdateOperationsInput = { + set?: boolean + } + + export type DateTimeFieldUpdateOperationsInput = { + set?: Date | string + } + + export type NullableIntFieldUpdateOperationsInput = { + set?: number | null + increment?: number + decrement?: number + multiply?: number + divide?: number + } + + export type NullableStringFieldUpdateOperationsInput = { + set?: string | null + } + + export type NestedIntFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> + in?: number[] + notIn?: number[] + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntFilter<$PrismaModel> | number + } + + export type NestedStringFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> + in?: string[] + notIn?: string[] + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringFilter<$PrismaModel> | string + } + + export type NestedIntWithAggregatesFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> + in?: number[] + notIn?: number[] + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntWithAggregatesFilter<$PrismaModel> | number + _count?: NestedIntFilter<$PrismaModel> + _avg?: NestedFloatFilter<$PrismaModel> + _sum?: NestedIntFilter<$PrismaModel> + _min?: NestedIntFilter<$PrismaModel> + _max?: NestedIntFilter<$PrismaModel> + } + + export type NestedFloatFilter<$PrismaModel = never> = { + equals?: number | FloatFieldRefInput<$PrismaModel> + in?: number[] + notIn?: number[] + lt?: number | FloatFieldRefInput<$PrismaModel> + lte?: number | FloatFieldRefInput<$PrismaModel> + gt?: number | FloatFieldRefInput<$PrismaModel> + gte?: number | FloatFieldRefInput<$PrismaModel> + not?: NestedFloatFilter<$PrismaModel> | number + } + + export type NestedStringWithAggregatesFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> + in?: string[] + notIn?: string[] + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringWithAggregatesFilter<$PrismaModel> | string + _count?: NestedIntFilter<$PrismaModel> + _min?: NestedStringFilter<$PrismaModel> + _max?: NestedStringFilter<$PrismaModel> + } + + export type NestedBoolFilter<$PrismaModel = never> = { + equals?: boolean | BooleanFieldRefInput<$PrismaModel> + not?: NestedBoolFilter<$PrismaModel> | boolean + } + + 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[] + notIn?: Date[] | string[] + lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + not?: NestedDateTimeFilter<$PrismaModel> | Date | string + } + + export type NestedIntNullableFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> | null + in?: number[] | null + notIn?: number[] | null + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntNullableFilter<$PrismaModel> | number | null + } + + export type NestedStringNullableFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> | null + in?: string[] | null + notIn?: string[] | null + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringNullableFilter<$PrismaModel> | string | null + } + + export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = { + equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> + in?: Date[] | string[] + notIn?: Date[] | string[] + lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> + gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> + not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string + _count?: NestedIntFilter<$PrismaModel> + _min?: NestedDateTimeFilter<$PrismaModel> + _max?: NestedDateTimeFilter<$PrismaModel> + } + + export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = { + equals?: number | IntFieldRefInput<$PrismaModel> | null + in?: number[] | null + notIn?: number[] | null + lt?: number | IntFieldRefInput<$PrismaModel> + lte?: number | IntFieldRefInput<$PrismaModel> + gt?: number | IntFieldRefInput<$PrismaModel> + gte?: number | IntFieldRefInput<$PrismaModel> + not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null + _count?: NestedIntNullableFilter<$PrismaModel> + _avg?: NestedFloatNullableFilter<$PrismaModel> + _sum?: NestedIntNullableFilter<$PrismaModel> + _min?: NestedIntNullableFilter<$PrismaModel> + _max?: NestedIntNullableFilter<$PrismaModel> + } + + export type NestedFloatNullableFilter<$PrismaModel = never> = { + equals?: number | FloatFieldRefInput<$PrismaModel> | null + in?: number[] | null + notIn?: number[] | null + lt?: number | FloatFieldRefInput<$PrismaModel> + lte?: number | FloatFieldRefInput<$PrismaModel> + gt?: number | FloatFieldRefInput<$PrismaModel> + gte?: number | FloatFieldRefInput<$PrismaModel> + not?: NestedFloatNullableFilter<$PrismaModel> | number | null + } + + export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = { + equals?: string | StringFieldRefInput<$PrismaModel> | null + in?: string[] | null + notIn?: string[] | null + lt?: string | StringFieldRefInput<$PrismaModel> + lte?: string | StringFieldRefInput<$PrismaModel> + gt?: string | StringFieldRefInput<$PrismaModel> + gte?: string | StringFieldRefInput<$PrismaModel> + contains?: string | StringFieldRefInput<$PrismaModel> + startsWith?: string | StringFieldRefInput<$PrismaModel> + endsWith?: string | StringFieldRefInput<$PrismaModel> + not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null + _count?: NestedIntNullableFilter<$PrismaModel> + _min?: NestedStringNullableFilter<$PrismaModel> + _max?: NestedStringNullableFilter<$PrismaModel> + } + + + + /** + * Batch Payload for updateMany & deleteMany & createMany + */ + + export type BatchPayload = { + count: number + } + + /** + * DMMF + */ + export const dmmf: runtime.BaseDMMF +} \ No newline at end of file