11506 lines
410 KiB
TypeScript
11506 lines
410 KiB
TypeScript
|
|
/**
|
|
* Client
|
|
**/
|
|
|
|
import * as runtime from './runtime/client.js';
|
|
import $Types = runtime.Types // general types
|
|
import $Public = runtime.Types.Public
|
|
import $Utils = runtime.Types.Utils
|
|
import $Extensions = runtime.Types.Extensions
|
|
import $Result = runtime.Types.Result
|
|
|
|
export type PrismaPromise<T> = $Public.PrismaPromise<T>
|
|
|
|
|
|
/**
|
|
* Model Task
|
|
*
|
|
*/
|
|
export type Task = $Result.DefaultSelection<Prisma.$TaskPayload>
|
|
/**
|
|
* Model Claim
|
|
*
|
|
*/
|
|
export type Claim = $Result.DefaultSelection<Prisma.$ClaimPayload>
|
|
/**
|
|
* Model Submission
|
|
*
|
|
*/
|
|
export type Submission = $Result.DefaultSelection<Prisma.$SubmissionPayload>
|
|
/**
|
|
* Model JudgeResult
|
|
*
|
|
*/
|
|
export type JudgeResult = $Result.DefaultSelection<Prisma.$JudgeResultPayload>
|
|
/**
|
|
* Model AuditEvent
|
|
*
|
|
*/
|
|
export type AuditEvent = $Result.DefaultSelection<Prisma.$AuditEventPayload>
|
|
/**
|
|
* Model LedgerEntry
|
|
*
|
|
*/
|
|
export type LedgerEntry = $Result.DefaultSelection<Prisma.$LedgerEntryPayload>
|
|
|
|
/**
|
|
* ## Prisma Client ʲˢ
|
|
*
|
|
* Type-safe database client for TypeScript & Node.js
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient({
|
|
* adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
|
|
* })
|
|
* // Fetch zero or more Tasks
|
|
* const tasks = await prisma.task.findMany()
|
|
* ```
|
|
*
|
|
*
|
|
* Read more in our [docs](https://pris.ly/d/client).
|
|
*/
|
|
export class PrismaClient<
|
|
ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
|
|
const U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
|
|
ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
|
|
> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
|
|
|
|
/**
|
|
* ## Prisma Client ʲˢ
|
|
*
|
|
* Type-safe database client for TypeScript & Node.js
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient({
|
|
* adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
|
|
* })
|
|
* // Fetch zero or more Tasks
|
|
* const tasks = await prisma.task.findMany()
|
|
* ```
|
|
*
|
|
*
|
|
* Read more in our [docs](https://pris.ly/d/client).
|
|
*/
|
|
|
|
constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
|
|
$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;
|
|
|
|
/**
|
|
* Connect with the database
|
|
*/
|
|
$connect(): $Utils.JsPromise<void>;
|
|
|
|
/**
|
|
* Disconnect from the database
|
|
*/
|
|
$disconnect(): $Utils.JsPromise<void>;
|
|
|
|
/**
|
|
* Executes a prepared raw query and returns the number of affected rows.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://pris.ly/d/raw-queries).
|
|
*/
|
|
$executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
|
|
|
|
/**
|
|
* Executes a raw query and returns the number of affected rows.
|
|
* Susceptible to SQL injections, see documentation.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://pris.ly/d/raw-queries).
|
|
*/
|
|
$executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
|
|
|
|
/**
|
|
* Performs a prepared raw query and returns the `SELECT` data.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://pris.ly/d/raw-queries).
|
|
*/
|
|
$queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
|
|
|
|
/**
|
|
* Performs a raw query and returns the `SELECT` data.
|
|
* Susceptible to SQL injections, see documentation.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://pris.ly/d/raw-queries).
|
|
*/
|
|
$queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
|
|
|
|
|
|
/**
|
|
* Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
|
|
* @example
|
|
* ```
|
|
* const [george, bob, alice] = await prisma.$transaction([
|
|
* prisma.user.create({ data: { name: 'George' } }),
|
|
* prisma.user.create({ data: { name: 'Bob' } }),
|
|
* prisma.user.create({ data: { name: 'Alice' } }),
|
|
* ])
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/orm/prisma-client/queries/transactions).
|
|
*/
|
|
$transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>
|
|
|
|
$transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => $Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<R>
|
|
|
|
$extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<ClientOptions>, ExtArgs, $Utils.Call<Prisma.TypeMapCb<ClientOptions>, {
|
|
extArgs: ExtArgs
|
|
}>>
|
|
|
|
/**
|
|
* `prisma.task`: Exposes CRUD operations for the **Task** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Tasks
|
|
* const tasks = await prisma.task.findMany()
|
|
* ```
|
|
*/
|
|
get task(): Prisma.TaskDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.claim`: Exposes CRUD operations for the **Claim** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Claims
|
|
* const claims = await prisma.claim.findMany()
|
|
* ```
|
|
*/
|
|
get claim(): Prisma.ClaimDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.submission`: Exposes CRUD operations for the **Submission** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Submissions
|
|
* const submissions = await prisma.submission.findMany()
|
|
* ```
|
|
*/
|
|
get submission(): Prisma.SubmissionDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.judgeResult`: Exposes CRUD operations for the **JudgeResult** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more JudgeResults
|
|
* const judgeResults = await prisma.judgeResult.findMany()
|
|
* ```
|
|
*/
|
|
get judgeResult(): Prisma.JudgeResultDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.auditEvent`: Exposes CRUD operations for the **AuditEvent** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more AuditEvents
|
|
* const auditEvents = await prisma.auditEvent.findMany()
|
|
* ```
|
|
*/
|
|
get auditEvent(): Prisma.AuditEventDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.ledgerEntry`: Exposes CRUD operations for the **LedgerEntry** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more LedgerEntries
|
|
* const ledgerEntries = await prisma.ledgerEntry.findMany()
|
|
* ```
|
|
*/
|
|
get ledgerEntry(): Prisma.LedgerEntryDelegate<ExtArgs, ClientOptions>;
|
|
}
|
|
|
|
export namespace Prisma {
|
|
export import DMMF = runtime.DMMF
|
|
|
|
export type PrismaPromise<T> = $Public.PrismaPromise<T>
|
|
|
|
/**
|
|
* Validator
|
|
*/
|
|
export import validator = runtime.Public.validator
|
|
|
|
/**
|
|
* Prisma Errors
|
|
*/
|
|
export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
|
|
export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
|
|
export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
|
|
export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
|
|
export import PrismaClientValidationError = runtime.PrismaClientValidationError
|
|
|
|
/**
|
|
* Re-export of sql-template-tag
|
|
*/
|
|
export import sql = runtime.sqltag
|
|
export import empty = runtime.empty
|
|
export import join = runtime.join
|
|
export import raw = runtime.raw
|
|
export import Sql = runtime.Sql
|
|
|
|
|
|
|
|
/**
|
|
* Decimal.js
|
|
*/
|
|
export import Decimal = runtime.Decimal
|
|
|
|
export type DecimalJsLike = runtime.DecimalJsLike
|
|
|
|
/**
|
|
* Extensions
|
|
*/
|
|
export import Extension = $Extensions.UserArgs
|
|
export import getExtensionContext = runtime.Extensions.getExtensionContext
|
|
export import Args = $Public.Args
|
|
export import Payload = $Public.Payload
|
|
export import Result = $Public.Result
|
|
export import Exact = $Public.Exact
|
|
|
|
/**
|
|
* Prisma Client JS version: 7.8.0
|
|
* Query Engine version: 3c6e192761c0362d496ed980de936e2f3cebcd3a
|
|
*/
|
|
export type PrismaVersion = {
|
|
client: string
|
|
engine: string
|
|
}
|
|
|
|
export const prismaVersion: PrismaVersion
|
|
|
|
/**
|
|
* Utility Types
|
|
*/
|
|
|
|
|
|
export import Bytes = runtime.Bytes
|
|
export import JsonObject = runtime.JsonObject
|
|
export import JsonArray = runtime.JsonArray
|
|
export import JsonValue = runtime.JsonValue
|
|
export import InputJsonObject = runtime.InputJsonObject
|
|
export import InputJsonArray = runtime.InputJsonArray
|
|
export import InputJsonValue = runtime.InputJsonValue
|
|
|
|
/**
|
|
* Types of the values used to represent different kinds of `null` values when working with JSON fields.
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
namespace NullTypes {
|
|
/**
|
|
* Type of `Prisma.DbNull`.
|
|
*
|
|
* You cannot use other instances of this class. Please use the `Prisma.DbNull` value.
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
class DbNull {
|
|
private DbNull: never
|
|
private constructor()
|
|
}
|
|
|
|
/**
|
|
* Type of `Prisma.JsonNull`.
|
|
*
|
|
* You cannot use other instances of this class. Please use the `Prisma.JsonNull` value.
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
class JsonNull {
|
|
private JsonNull: never
|
|
private constructor()
|
|
}
|
|
|
|
/**
|
|
* Type of `Prisma.AnyNull`.
|
|
*
|
|
* You cannot use other instances of this class. Please use the `Prisma.AnyNull` value.
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
class AnyNull {
|
|
private AnyNull: never
|
|
private constructor()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper for filtering JSON entries that have `null` on the database (empty on the db)
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
export const DbNull: NullTypes.DbNull
|
|
|
|
/**
|
|
* Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
export const JsonNull: NullTypes.JsonNull
|
|
|
|
/**
|
|
* Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
|
|
*
|
|
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
|
|
*/
|
|
export const AnyNull: NullTypes.AnyNull
|
|
|
|
type SelectAndInclude = {
|
|
select: any
|
|
include: any
|
|
}
|
|
|
|
type SelectAndOmit = {
|
|
select: any
|
|
omit: any
|
|
}
|
|
|
|
/**
|
|
* Get the type of the value, that the Promise holds.
|
|
*/
|
|
export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
|
|
|
|
/**
|
|
* Get the return type of a function which returns a Promise.
|
|
*/
|
|
export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>
|
|
|
|
/**
|
|
* From T, pick a set of properties whose keys are in the union K
|
|
*/
|
|
type Prisma__Pick<T, K extends keyof T> = {
|
|
[P in K]: T[P];
|
|
};
|
|
|
|
|
|
export type Enumerable<T> = T | Array<T>;
|
|
|
|
export type RequiredKeys<T> = {
|
|
[K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
|
|
}[keyof T]
|
|
|
|
export type TruthyKeys<T> = keyof {
|
|
[K in keyof T as T[K] extends false | undefined | null ? never : K]: K
|
|
}
|
|
|
|
export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
|
|
|
|
/**
|
|
* Subset
|
|
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection
|
|
*/
|
|
export type Subset<T, U> = {
|
|
[key in keyof T]: key extends keyof U ? T[key] : never;
|
|
};
|
|
|
|
/**
|
|
* SelectSubset
|
|
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
|
|
* Additionally, it validates, if both select and include are present. If the case, it errors.
|
|
*/
|
|
export type SelectSubset<T, U> = {
|
|
[key in keyof T]: key extends keyof U ? T[key] : never
|
|
} &
|
|
(T extends SelectAndInclude
|
|
? 'Please either choose `select` or `include`.'
|
|
: T extends SelectAndOmit
|
|
? 'Please either choose `select` or `omit`.'
|
|
: {})
|
|
|
|
/**
|
|
* Subset + Intersection
|
|
* @desc From `T` pick properties that exist in `U` and intersect `K`
|
|
*/
|
|
export type SubsetIntersection<T, U, K> = {
|
|
[key in keyof T]: key extends keyof U ? T[key] : never
|
|
} &
|
|
K
|
|
|
|
type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
|
|
|
|
/**
|
|
* XOR is needed to have a real mutually exclusive union type
|
|
* https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
|
|
*/
|
|
type XOR<T, U> =
|
|
T extends object ?
|
|
U extends object ?
|
|
(Without<T, U> & U) | (Without<U, T> & T)
|
|
: U : T
|
|
|
|
|
|
/**
|
|
* Is T a Record?
|
|
*/
|
|
type IsObject<T extends any> = T extends Array<any>
|
|
? False
|
|
: T extends Date
|
|
? False
|
|
: T extends Uint8Array
|
|
? False
|
|
: T extends BigInt
|
|
? False
|
|
: T extends object
|
|
? True
|
|
: False
|
|
|
|
|
|
/**
|
|
* If it's T[], return T
|
|
*/
|
|
export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
|
|
|
|
/**
|
|
* From ts-toolbelt
|
|
*/
|
|
|
|
type __Either<O extends object, K extends Key> = Omit<O, K> &
|
|
{
|
|
// Merge all but K
|
|
[P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
|
|
}[K]
|
|
|
|
type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
|
|
|
|
type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
|
|
|
|
type _Either<
|
|
O extends object,
|
|
K extends Key,
|
|
strict extends Boolean
|
|
> = {
|
|
1: EitherStrict<O, K>
|
|
0: EitherLoose<O, K>
|
|
}[strict]
|
|
|
|
type Either<
|
|
O extends object,
|
|
K extends Key,
|
|
strict extends Boolean = 1
|
|
> = O extends unknown ? _Either<O, K, strict> : never
|
|
|
|
export type Union = any
|
|
|
|
type PatchUndefined<O extends object, O1 extends object> = {
|
|
[K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
|
|
} & {}
|
|
|
|
/** Helper Types for "Merge" **/
|
|
export type IntersectOf<U extends Union> = (
|
|
U extends unknown ? (k: U) => void : never
|
|
) extends (k: infer I) => void
|
|
? I
|
|
: never
|
|
|
|
export type Overwrite<O extends object, O1 extends object> = {
|
|
[K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
|
|
} & {};
|
|
|
|
type _Merge<U extends object> = IntersectOf<Overwrite<U, {
|
|
[K in keyof U]-?: At<U, K>;
|
|
}>>;
|
|
|
|
type Key = string | number | symbol;
|
|
type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
|
|
type AtStrict<O extends object, K extends Key> = O[K & keyof O];
|
|
type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
|
|
export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
|
|
1: AtStrict<O, K>;
|
|
0: AtLoose<O, K>;
|
|
}[strict];
|
|
|
|
export type ComputeRaw<A extends any> = A extends Function ? A : {
|
|
[K in keyof A]: A[K];
|
|
} & {};
|
|
|
|
export type OptionalFlat<O> = {
|
|
[K in keyof O]?: O[K];
|
|
} & {};
|
|
|
|
type _Record<K extends keyof any, T> = {
|
|
[P in K]: T;
|
|
};
|
|
|
|
// cause typescript not to expand types and preserve names
|
|
type NoExpand<T> = T extends unknown ? T : never;
|
|
|
|
// this type assumes the passed object is entirely optional
|
|
type AtLeast<O extends object, K extends string> = NoExpand<
|
|
O extends unknown
|
|
? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
|
|
| {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
|
|
: never>;
|
|
|
|
type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
|
|
|
|
export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
|
|
/** End Helper Types for "Merge" **/
|
|
|
|
export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
|
|
|
|
/**
|
|
A [[Boolean]]
|
|
*/
|
|
export type Boolean = True | False
|
|
|
|
// /**
|
|
// 1
|
|
// */
|
|
export type True = 1
|
|
|
|
/**
|
|
0
|
|
*/
|
|
export type False = 0
|
|
|
|
export type Not<B extends Boolean> = {
|
|
0: 1
|
|
1: 0
|
|
}[B]
|
|
|
|
export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
|
|
? 0 // anything `never` is false
|
|
: A1 extends A2
|
|
? 1
|
|
: 0
|
|
|
|
export type Has<U extends Union, U1 extends Union> = Not<
|
|
Extends<Exclude<U1, U>, U1>
|
|
>
|
|
|
|
export type Or<B1 extends Boolean, B2 extends Boolean> = {
|
|
0: {
|
|
0: 0
|
|
1: 1
|
|
}
|
|
1: {
|
|
0: 1
|
|
1: 1
|
|
}
|
|
}[B1][B2]
|
|
|
|
export type Keys<U extends Union> = U extends unknown ? keyof U : never
|
|
|
|
type Cast<A, B> = A extends B ? A : B;
|
|
|
|
export const type: unique symbol;
|
|
|
|
|
|
|
|
/**
|
|
* Used by group by
|
|
*/
|
|
|
|
export type GetScalarType<T, O> = O extends object ? {
|
|
[P in keyof T]: P extends keyof O
|
|
? O[P]
|
|
: never
|
|
} : never
|
|
|
|
type FieldPaths<
|
|
T,
|
|
U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
|
|
> = IsObject<T> extends True ? U : T
|
|
|
|
type GetHavingFields<T> = {
|
|
[K in keyof T]: Or<
|
|
Or<Extends<'OR', K>, Extends<'AND', K>>,
|
|
Extends<'NOT', K>
|
|
> extends True
|
|
? // infer is only needed to not hit TS limit
|
|
// based on the brilliant idea of Pierre-Antoine Mills
|
|
// https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
|
|
T[K] extends infer TK
|
|
? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
|
|
: never
|
|
: {} extends FieldPaths<T[K]>
|
|
? never
|
|
: K
|
|
}[keyof T]
|
|
|
|
/**
|
|
* Convert tuple to union
|
|
*/
|
|
type _TupleToUnion<T> = T extends (infer E)[] ? E : never
|
|
type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
|
|
type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
|
|
|
|
/**
|
|
* Like `Pick`, but additionally can also accept an array of keys
|
|
*/
|
|
type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
|
|
|
|
/**
|
|
* Exclude all keys with underscores
|
|
*/
|
|
type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T
|
|
|
|
|
|
export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
|
|
|
|
type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
|
|
|
|
|
|
export const ModelName: {
|
|
Task: 'Task',
|
|
Claim: 'Claim',
|
|
Submission: 'Submission',
|
|
JudgeResult: 'JudgeResult',
|
|
AuditEvent: 'AuditEvent',
|
|
LedgerEntry: 'LedgerEntry'
|
|
};
|
|
|
|
export type ModelName = (typeof ModelName)[keyof typeof ModelName]
|
|
|
|
|
|
|
|
interface TypeMapCb<ClientOptions = {}> extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record<string, any>> {
|
|
returns: Prisma.TypeMap<this['params']['extArgs'], ClientOptions extends { omit: infer OmitOptions } ? OmitOptions : {}>
|
|
}
|
|
|
|
export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
|
|
globalOmitOptions: {
|
|
omit: GlobalOmitOptions
|
|
}
|
|
meta: {
|
|
modelProps: "task" | "claim" | "submission" | "judgeResult" | "auditEvent" | "ledgerEntry"
|
|
txIsolationLevel: Prisma.TransactionIsolationLevel
|
|
}
|
|
model: {
|
|
Task: {
|
|
payload: Prisma.$TaskPayload<ExtArgs>
|
|
fields: Prisma.TaskFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.TaskFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.TaskFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.TaskFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.TaskFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.TaskFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.TaskCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.TaskCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.TaskCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.TaskDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.TaskUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.TaskDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.TaskUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.TaskUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.TaskUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$TaskPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.TaskAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateTask>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.TaskGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<TaskGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.TaskCountArgs<ExtArgs>
|
|
result: $Utils.Optional<TaskCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Claim: {
|
|
payload: Prisma.$ClaimPayload<ExtArgs>
|
|
fields: Prisma.ClaimFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.ClaimFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.ClaimFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.ClaimFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.ClaimFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.ClaimFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.ClaimCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.ClaimCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.ClaimCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.ClaimDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.ClaimUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.ClaimDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.ClaimUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.ClaimUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.ClaimUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ClaimPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.ClaimAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateClaim>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.ClaimGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<ClaimGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.ClaimCountArgs<ExtArgs>
|
|
result: $Utils.Optional<ClaimCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Submission: {
|
|
payload: Prisma.$SubmissionPayload<ExtArgs>
|
|
fields: Prisma.SubmissionFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.SubmissionFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.SubmissionFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.SubmissionFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.SubmissionFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.SubmissionFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.SubmissionCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.SubmissionCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.SubmissionCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.SubmissionDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.SubmissionUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.SubmissionDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.SubmissionUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.SubmissionUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.SubmissionUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SubmissionPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.SubmissionAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateSubmission>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.SubmissionGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<SubmissionGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.SubmissionCountArgs<ExtArgs>
|
|
result: $Utils.Optional<SubmissionCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
JudgeResult: {
|
|
payload: Prisma.$JudgeResultPayload<ExtArgs>
|
|
fields: Prisma.JudgeResultFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.JudgeResultFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.JudgeResultFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.JudgeResultFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.JudgeResultFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.JudgeResultFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.JudgeResultCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.JudgeResultCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.JudgeResultCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.JudgeResultDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.JudgeResultUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.JudgeResultDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.JudgeResultUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.JudgeResultUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.JudgeResultUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$JudgeResultPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.JudgeResultAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateJudgeResult>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.JudgeResultGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<JudgeResultGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.JudgeResultCountArgs<ExtArgs>
|
|
result: $Utils.Optional<JudgeResultCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
AuditEvent: {
|
|
payload: Prisma.$AuditEventPayload<ExtArgs>
|
|
fields: Prisma.AuditEventFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.AuditEventFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.AuditEventFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.AuditEventFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.AuditEventFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.AuditEventFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.AuditEventCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.AuditEventCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.AuditEventCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.AuditEventDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.AuditEventUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.AuditEventDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.AuditEventUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.AuditEventUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.AuditEventUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AuditEventPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.AuditEventAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateAuditEvent>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.AuditEventGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<AuditEventGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.AuditEventCountArgs<ExtArgs>
|
|
result: $Utils.Optional<AuditEventCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
LedgerEntry: {
|
|
payload: Prisma.$LedgerEntryPayload<ExtArgs>
|
|
fields: Prisma.LedgerEntryFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.LedgerEntryFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.LedgerEntryFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.LedgerEntryFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.LedgerEntryFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.LedgerEntryFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.LedgerEntryCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.LedgerEntryCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.LedgerEntryCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.LedgerEntryDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.LedgerEntryUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.LedgerEntryDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.LedgerEntryUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.LedgerEntryUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.LedgerEntryUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.LedgerEntryAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateLedgerEntry>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.LedgerEntryGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<LedgerEntryGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.LedgerEntryCountArgs<ExtArgs>
|
|
result: $Utils.Optional<LedgerEntryCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} & {
|
|
other: {
|
|
payload: any
|
|
operations: {
|
|
$executeRaw: {
|
|
args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
|
|
result: any
|
|
}
|
|
$executeRawUnsafe: {
|
|
args: [query: string, ...values: any[]],
|
|
result: any
|
|
}
|
|
$queryRaw: {
|
|
args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
|
|
result: any
|
|
}
|
|
$queryRawUnsafe: {
|
|
args: [query: string, ...values: any[]],
|
|
result: any
|
|
}
|
|
}
|
|
}
|
|
}
|
|
export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
|
|
export type DefaultPrismaClient = PrismaClient
|
|
export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
|
|
export interface PrismaClientOptions {
|
|
/**
|
|
* @default "colorless"
|
|
*/
|
|
errorFormat?: ErrorFormat
|
|
/**
|
|
* @example
|
|
* ```
|
|
* // Shorthand for `emit: 'stdout'`
|
|
* log: ['query', 'info', 'warn', 'error']
|
|
*
|
|
* // Emit as events only
|
|
* log: [
|
|
* { emit: 'event', level: 'query' },
|
|
* { emit: 'event', level: 'info' },
|
|
* { emit: 'event', level: 'warn' }
|
|
* { emit: 'event', level: 'error' }
|
|
* ]
|
|
*
|
|
* / Emit as events and log to stdout
|
|
* og: [
|
|
* { emit: 'stdout', level: 'query' },
|
|
* { emit: 'stdout', level: 'info' },
|
|
* { emit: 'stdout', level: 'warn' }
|
|
* { emit: 'stdout', level: 'error' }
|
|
*
|
|
* ```
|
|
* Read more in our [docs](https://pris.ly/d/logging).
|
|
*/
|
|
log?: (LogLevel | LogDefinition)[]
|
|
/**
|
|
* The default values for transactionOptions
|
|
* maxWait ?= 2000
|
|
* timeout ?= 5000
|
|
*/
|
|
transactionOptions?: {
|
|
maxWait?: number
|
|
timeout?: number
|
|
isolationLevel?: Prisma.TransactionIsolationLevel
|
|
}
|
|
/**
|
|
* Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`
|
|
*/
|
|
adapter?: runtime.SqlDriverAdapterFactory
|
|
/**
|
|
* Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
|
|
*/
|
|
accelerateUrl?: string
|
|
/**
|
|
* Global configuration for omitting model fields by default.
|
|
*
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient({
|
|
* omit: {
|
|
* user: {
|
|
* password: true
|
|
* }
|
|
* }
|
|
* })
|
|
* ```
|
|
*/
|
|
omit?: Prisma.GlobalOmitConfig
|
|
/**
|
|
* SQL commenter plugins that add metadata to SQL queries as comments.
|
|
* Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
|
|
*
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient({
|
|
* adapter,
|
|
* comments: [
|
|
* traceContext(),
|
|
* queryInsights(),
|
|
* ],
|
|
* })
|
|
* ```
|
|
*/
|
|
comments?: runtime.SqlCommenterPlugin[]
|
|
}
|
|
export type GlobalOmitConfig = {
|
|
task?: TaskOmit
|
|
claim?: ClaimOmit
|
|
submission?: SubmissionOmit
|
|
judgeResult?: JudgeResultOmit
|
|
auditEvent?: AuditEventOmit
|
|
ledgerEntry?: LedgerEntryOmit
|
|
}
|
|
|
|
/* Types for Logging */
|
|
export type LogLevel = 'info' | 'query' | 'warn' | 'error'
|
|
export type LogDefinition = {
|
|
level: LogLevel
|
|
emit: 'stdout' | 'event'
|
|
}
|
|
|
|
export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;
|
|
|
|
export type GetLogType<T> = CheckIsLogLevel<
|
|
T extends LogDefinition ? T['level'] : T
|
|
>;
|
|
|
|
export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition>
|
|
? GetLogType<T[number]>
|
|
: never;
|
|
|
|
export type QueryEvent = {
|
|
timestamp: Date
|
|
query: string
|
|
params: string
|
|
duration: number
|
|
target: string
|
|
}
|
|
|
|
export type LogEvent = {
|
|
timestamp: Date
|
|
message: string
|
|
target: string
|
|
}
|
|
/* End Types for Logging */
|
|
|
|
|
|
export type PrismaAction =
|
|
| 'findUnique'
|
|
| 'findUniqueOrThrow'
|
|
| 'findMany'
|
|
| 'findFirst'
|
|
| 'findFirstOrThrow'
|
|
| 'create'
|
|
| 'createMany'
|
|
| 'createManyAndReturn'
|
|
| 'update'
|
|
| 'updateMany'
|
|
| 'updateManyAndReturn'
|
|
| 'upsert'
|
|
| 'delete'
|
|
| 'deleteMany'
|
|
| 'executeRaw'
|
|
| 'queryRaw'
|
|
| 'aggregate'
|
|
| 'count'
|
|
| 'runCommandRaw'
|
|
| 'findRaw'
|
|
| 'groupBy'
|
|
|
|
// tested in getLogLevel.test.ts
|
|
export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
|
|
|
|
/**
|
|
* `PrismaClient` proxy available in interactive transactions.
|
|
*/
|
|
export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>
|
|
|
|
export type Datasource = {
|
|
url?: string
|
|
}
|
|
|
|
/**
|
|
* Count Types
|
|
*/
|
|
|
|
|
|
/**
|
|
* Count Type TaskCountOutputType
|
|
*/
|
|
|
|
export type TaskCountOutputType = {
|
|
claims: number
|
|
submissions: number
|
|
}
|
|
|
|
export type TaskCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
claims?: boolean | TaskCountOutputTypeCountClaimsArgs
|
|
submissions?: boolean | TaskCountOutputTypeCountSubmissionsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* TaskCountOutputType without action
|
|
*/
|
|
export type TaskCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the TaskCountOutputType
|
|
*/
|
|
select?: TaskCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* TaskCountOutputType without action
|
|
*/
|
|
export type TaskCountOutputTypeCountClaimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ClaimWhereInput
|
|
}
|
|
|
|
/**
|
|
* TaskCountOutputType without action
|
|
*/
|
|
export type TaskCountOutputTypeCountSubmissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SubmissionWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type ClaimCountOutputType
|
|
*/
|
|
|
|
export type ClaimCountOutputType = {
|
|
submissions: number
|
|
}
|
|
|
|
export type ClaimCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
submissions?: boolean | ClaimCountOutputTypeCountSubmissionsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* ClaimCountOutputType without action
|
|
*/
|
|
export type ClaimCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ClaimCountOutputType
|
|
*/
|
|
select?: ClaimCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* ClaimCountOutputType without action
|
|
*/
|
|
export type ClaimCountOutputTypeCountSubmissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SubmissionWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type SubmissionCountOutputType
|
|
*/
|
|
|
|
export type SubmissionCountOutputType = {
|
|
judge_results: number
|
|
}
|
|
|
|
export type SubmissionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
judge_results?: boolean | SubmissionCountOutputTypeCountJudge_resultsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* SubmissionCountOutputType without action
|
|
*/
|
|
export type SubmissionCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SubmissionCountOutputType
|
|
*/
|
|
select?: SubmissionCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* SubmissionCountOutputType without action
|
|
*/
|
|
export type SubmissionCountOutputTypeCountJudge_resultsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: JudgeResultWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Models
|
|
*/
|
|
|
|
/**
|
|
* Model Task
|
|
*/
|
|
|
|
export type AggregateTask = {
|
|
_count: TaskCountAggregateOutputType | null
|
|
_avg: TaskAvgAggregateOutputType | null
|
|
_sum: TaskSumAggregateOutputType | null
|
|
_min: TaskMinAggregateOutputType | null
|
|
_max: TaskMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type TaskAvgAggregateOutputType = {
|
|
scope_clarity_score: number | null
|
|
reward_amount: number | null
|
|
retry_count: number | null
|
|
}
|
|
|
|
export type TaskSumAggregateOutputType = {
|
|
scope_clarity_score: number | null
|
|
reward_amount: number | null
|
|
retry_count: number | null
|
|
}
|
|
|
|
export type TaskMinAggregateOutputType = {
|
|
id: string | null
|
|
title: string | null
|
|
description: string | null
|
|
status: string | null
|
|
difficulty: string | null
|
|
scope_clarity_score: number | null
|
|
error_classification: string | null
|
|
reward_amount: number | null
|
|
reward_currency: string | null
|
|
retry_count: number | null
|
|
stripe_payment_intent_id: string | null
|
|
expires_at: Date | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type TaskMaxAggregateOutputType = {
|
|
id: string | null
|
|
title: string | null
|
|
description: string | null
|
|
status: string | null
|
|
difficulty: string | null
|
|
scope_clarity_score: number | null
|
|
error_classification: string | null
|
|
reward_amount: number | null
|
|
reward_currency: string | null
|
|
retry_count: number | null
|
|
stripe_payment_intent_id: string | null
|
|
expires_at: Date | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type TaskCountAggregateOutputType = {
|
|
id: number
|
|
title: number
|
|
description: number
|
|
status: number
|
|
difficulty: number
|
|
scope_clarity_score: number
|
|
error_classification: number
|
|
reward_amount: number
|
|
reward_currency: number
|
|
acceptance_criteria: number
|
|
required_stack: number
|
|
retry_count: number
|
|
stripe_payment_intent_id: number
|
|
expires_at: number
|
|
created_at: number
|
|
updated_at: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type TaskAvgAggregateInputType = {
|
|
scope_clarity_score?: true
|
|
reward_amount?: true
|
|
retry_count?: true
|
|
}
|
|
|
|
export type TaskSumAggregateInputType = {
|
|
scope_clarity_score?: true
|
|
reward_amount?: true
|
|
retry_count?: true
|
|
}
|
|
|
|
export type TaskMinAggregateInputType = {
|
|
id?: true
|
|
title?: true
|
|
description?: true
|
|
status?: true
|
|
difficulty?: true
|
|
scope_clarity_score?: true
|
|
error_classification?: true
|
|
reward_amount?: true
|
|
reward_currency?: true
|
|
retry_count?: true
|
|
stripe_payment_intent_id?: true
|
|
expires_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type TaskMaxAggregateInputType = {
|
|
id?: true
|
|
title?: true
|
|
description?: true
|
|
status?: true
|
|
difficulty?: true
|
|
scope_clarity_score?: true
|
|
error_classification?: true
|
|
reward_amount?: true
|
|
reward_currency?: true
|
|
retry_count?: true
|
|
stripe_payment_intent_id?: true
|
|
expires_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type TaskCountAggregateInputType = {
|
|
id?: true
|
|
title?: true
|
|
description?: true
|
|
status?: true
|
|
difficulty?: true
|
|
scope_clarity_score?: true
|
|
error_classification?: true
|
|
reward_amount?: true
|
|
reward_currency?: true
|
|
acceptance_criteria?: true
|
|
required_stack?: true
|
|
retry_count?: true
|
|
stripe_payment_intent_id?: true
|
|
expires_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type TaskAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Task to aggregate.
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Tasks to fetch.
|
|
*/
|
|
orderBy?: TaskOrderByWithRelationInput | TaskOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: TaskWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Tasks from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Tasks.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Tasks
|
|
**/
|
|
_count?: true | TaskCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: TaskAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: TaskSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: TaskMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: TaskMaxAggregateInputType
|
|
}
|
|
|
|
export type GetTaskAggregateType<T extends TaskAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateTask]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateTask[P]>
|
|
: GetScalarType<T[P], AggregateTask[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type TaskGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: TaskWhereInput
|
|
orderBy?: TaskOrderByWithAggregationInput | TaskOrderByWithAggregationInput[]
|
|
by: TaskScalarFieldEnum[] | TaskScalarFieldEnum
|
|
having?: TaskScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: TaskCountAggregateInputType | true
|
|
_avg?: TaskAvgAggregateInputType
|
|
_sum?: TaskSumAggregateInputType
|
|
_min?: TaskMinAggregateInputType
|
|
_max?: TaskMaxAggregateInputType
|
|
}
|
|
|
|
export type TaskGroupByOutputType = {
|
|
id: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonValue
|
|
required_stack: string[]
|
|
retry_count: number
|
|
stripe_payment_intent_id: string | null
|
|
expires_at: Date | null
|
|
created_at: Date
|
|
updated_at: Date
|
|
_count: TaskCountAggregateOutputType | null
|
|
_avg: TaskAvgAggregateOutputType | null
|
|
_sum: TaskSumAggregateOutputType | null
|
|
_min: TaskMinAggregateOutputType | null
|
|
_max: TaskMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetTaskGroupByPayload<T extends TaskGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<TaskGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof TaskGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], TaskGroupByOutputType[P]>
|
|
: GetScalarType<T[P], TaskGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type TaskSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
status?: boolean
|
|
difficulty?: boolean
|
|
scope_clarity_score?: boolean
|
|
error_classification?: boolean
|
|
reward_amount?: boolean
|
|
reward_currency?: boolean
|
|
acceptance_criteria?: boolean
|
|
required_stack?: boolean
|
|
retry_count?: boolean
|
|
stripe_payment_intent_id?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
claims?: boolean | Task$claimsArgs<ExtArgs>
|
|
submissions?: boolean | Task$submissionsArgs<ExtArgs>
|
|
_count?: boolean | TaskCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["task"]>
|
|
|
|
export type TaskSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
status?: boolean
|
|
difficulty?: boolean
|
|
scope_clarity_score?: boolean
|
|
error_classification?: boolean
|
|
reward_amount?: boolean
|
|
reward_currency?: boolean
|
|
acceptance_criteria?: boolean
|
|
required_stack?: boolean
|
|
retry_count?: boolean
|
|
stripe_payment_intent_id?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}, ExtArgs["result"]["task"]>
|
|
|
|
export type TaskSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
status?: boolean
|
|
difficulty?: boolean
|
|
scope_clarity_score?: boolean
|
|
error_classification?: boolean
|
|
reward_amount?: boolean
|
|
reward_currency?: boolean
|
|
acceptance_criteria?: boolean
|
|
required_stack?: boolean
|
|
retry_count?: boolean
|
|
stripe_payment_intent_id?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}, ExtArgs["result"]["task"]>
|
|
|
|
export type TaskSelectScalar = {
|
|
id?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
status?: boolean
|
|
difficulty?: boolean
|
|
scope_clarity_score?: boolean
|
|
error_classification?: boolean
|
|
reward_amount?: boolean
|
|
reward_currency?: boolean
|
|
acceptance_criteria?: boolean
|
|
required_stack?: boolean
|
|
retry_count?: boolean
|
|
stripe_payment_intent_id?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}
|
|
|
|
export type TaskOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "title" | "description" | "status" | "difficulty" | "scope_clarity_score" | "error_classification" | "reward_amount" | "reward_currency" | "acceptance_criteria" | "required_stack" | "retry_count" | "stripe_payment_intent_id" | "expires_at" | "created_at" | "updated_at", ExtArgs["result"]["task"]>
|
|
export type TaskInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
claims?: boolean | Task$claimsArgs<ExtArgs>
|
|
submissions?: boolean | Task$submissionsArgs<ExtArgs>
|
|
_count?: boolean | TaskCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type TaskIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
export type TaskIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $TaskPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Task"
|
|
objects: {
|
|
claims: Prisma.$ClaimPayload<ExtArgs>[]
|
|
submissions: Prisma.$SubmissionPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: Prisma.JsonValue
|
|
required_stack: string[]
|
|
retry_count: number
|
|
stripe_payment_intent_id: string | null
|
|
expires_at: Date | null
|
|
created_at: Date
|
|
updated_at: Date
|
|
}, ExtArgs["result"]["task"]>
|
|
composites: {}
|
|
}
|
|
|
|
type TaskGetPayload<S extends boolean | null | undefined | TaskDefaultArgs> = $Result.GetResult<Prisma.$TaskPayload, S>
|
|
|
|
type TaskCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<TaskFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: TaskCountAggregateInputType | true
|
|
}
|
|
|
|
export interface TaskDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Task'], meta: { name: 'Task' } }
|
|
/**
|
|
* Find zero or one Task that matches the filter.
|
|
* @param {TaskFindUniqueArgs} args - Arguments to find a Task
|
|
* @example
|
|
* // Get one Task
|
|
* const task = await prisma.task.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends TaskFindUniqueArgs>(args: SelectSubset<T, TaskFindUniqueArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Task that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {TaskFindUniqueOrThrowArgs} args - Arguments to find a Task
|
|
* @example
|
|
* // Get one Task
|
|
* const task = await prisma.task.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends TaskFindUniqueOrThrowArgs>(args: SelectSubset<T, TaskFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Task 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 {TaskFindFirstArgs} args - Arguments to find a Task
|
|
* @example
|
|
* // Get one Task
|
|
* const task = await prisma.task.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends TaskFindFirstArgs>(args?: SelectSubset<T, TaskFindFirstArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Task 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 {TaskFindFirstOrThrowArgs} args - Arguments to find a Task
|
|
* @example
|
|
* // Get one Task
|
|
* const task = await prisma.task.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends TaskFindFirstOrThrowArgs>(args?: SelectSubset<T, TaskFindFirstOrThrowArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Tasks 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 {TaskFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Tasks
|
|
* const tasks = await prisma.task.findMany()
|
|
*
|
|
* // Get first 10 Tasks
|
|
* const tasks = await prisma.task.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const taskWithIdOnly = await prisma.task.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends TaskFindManyArgs>(args?: SelectSubset<T, TaskFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Task.
|
|
* @param {TaskCreateArgs} args - Arguments to create a Task.
|
|
* @example
|
|
* // Create one Task
|
|
* const Task = await prisma.task.create({
|
|
* data: {
|
|
* // ... data to create a Task
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends TaskCreateArgs>(args: SelectSubset<T, TaskCreateArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Tasks.
|
|
* @param {TaskCreateManyArgs} args - Arguments to create many Tasks.
|
|
* @example
|
|
* // Create many Tasks
|
|
* const task = await prisma.task.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends TaskCreateManyArgs>(args?: SelectSubset<T, TaskCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Tasks and returns the data saved in the database.
|
|
* @param {TaskCreateManyAndReturnArgs} args - Arguments to create many Tasks.
|
|
* @example
|
|
* // Create many Tasks
|
|
* const task = await prisma.task.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Tasks and only return the `id`
|
|
* const taskWithIdOnly = await prisma.task.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends TaskCreateManyAndReturnArgs>(args?: SelectSubset<T, TaskCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Task.
|
|
* @param {TaskDeleteArgs} args - Arguments to delete one Task.
|
|
* @example
|
|
* // Delete one Task
|
|
* const Task = await prisma.task.delete({
|
|
* where: {
|
|
* // ... filter to delete one Task
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends TaskDeleteArgs>(args: SelectSubset<T, TaskDeleteArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Task.
|
|
* @param {TaskUpdateArgs} args - Arguments to update one Task.
|
|
* @example
|
|
* // Update one Task
|
|
* const task = await prisma.task.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends TaskUpdateArgs>(args: SelectSubset<T, TaskUpdateArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Tasks.
|
|
* @param {TaskDeleteManyArgs} args - Arguments to filter Tasks to delete.
|
|
* @example
|
|
* // Delete a few Tasks
|
|
* const { count } = await prisma.task.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends TaskDeleteManyArgs>(args?: SelectSubset<T, TaskDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Tasks.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {TaskUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Tasks
|
|
* const task = await prisma.task.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends TaskUpdateManyArgs>(args: SelectSubset<T, TaskUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Tasks and returns the data updated in the database.
|
|
* @param {TaskUpdateManyAndReturnArgs} args - Arguments to update many Tasks.
|
|
* @example
|
|
* // Update many Tasks
|
|
* const task = await prisma.task.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Tasks and only return the `id`
|
|
* const taskWithIdOnly = await prisma.task.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends TaskUpdateManyAndReturnArgs>(args: SelectSubset<T, TaskUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Task.
|
|
* @param {TaskUpsertArgs} args - Arguments to update or create a Task.
|
|
* @example
|
|
* // Update or create a Task
|
|
* const task = await prisma.task.upsert({
|
|
* create: {
|
|
* // ... data to create a Task
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Task we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends TaskUpsertArgs>(args: SelectSubset<T, TaskUpsertArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Tasks.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {TaskCountArgs} args - Arguments to filter Tasks to count.
|
|
* @example
|
|
* // Count the number of Tasks
|
|
* const count = await prisma.task.count({
|
|
* where: {
|
|
* // ... the filter for the Tasks we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends TaskCountArgs>(
|
|
args?: Subset<T, TaskCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], TaskCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Task.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {TaskAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends TaskAggregateArgs>(args: Subset<T, TaskAggregateArgs>): Prisma.PrismaPromise<GetTaskAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Task.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {TaskGroupByArgs} 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 TaskGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: TaskGroupByArgs['orderBy'] }
|
|
: { orderBy?: TaskGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, TaskGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTaskGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Task model
|
|
*/
|
|
readonly fields: TaskFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Task.
|
|
* 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__TaskClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
claims<T extends Task$claimsArgs<ExtArgs> = {}>(args?: Subset<T, Task$claimsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
submissions<T extends Task$submissionsArgs<ExtArgs> = {}>(args?: Subset<T, Task$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the Task model
|
|
*/
|
|
interface TaskFieldRefs {
|
|
readonly id: FieldRef<"Task", 'String'>
|
|
readonly title: FieldRef<"Task", 'String'>
|
|
readonly description: FieldRef<"Task", 'String'>
|
|
readonly status: FieldRef<"Task", 'String'>
|
|
readonly difficulty: FieldRef<"Task", 'String'>
|
|
readonly scope_clarity_score: FieldRef<"Task", 'Float'>
|
|
readonly error_classification: FieldRef<"Task", 'String'>
|
|
readonly reward_amount: FieldRef<"Task", 'Int'>
|
|
readonly reward_currency: FieldRef<"Task", 'String'>
|
|
readonly acceptance_criteria: FieldRef<"Task", 'Json'>
|
|
readonly required_stack: FieldRef<"Task", 'String[]'>
|
|
readonly retry_count: FieldRef<"Task", 'Int'>
|
|
readonly stripe_payment_intent_id: FieldRef<"Task", 'String'>
|
|
readonly expires_at: FieldRef<"Task", 'DateTime'>
|
|
readonly created_at: FieldRef<"Task", 'DateTime'>
|
|
readonly updated_at: FieldRef<"Task", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Task findUnique
|
|
*/
|
|
export type TaskFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Task to fetch.
|
|
*/
|
|
where: TaskWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Task findUniqueOrThrow
|
|
*/
|
|
export type TaskFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Task to fetch.
|
|
*/
|
|
where: TaskWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Task findFirst
|
|
*/
|
|
export type TaskFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Task to fetch.
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Tasks to fetch.
|
|
*/
|
|
orderBy?: TaskOrderByWithRelationInput | TaskOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Tasks.
|
|
*/
|
|
cursor?: TaskWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Tasks from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Tasks.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Tasks.
|
|
*/
|
|
distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Task findFirstOrThrow
|
|
*/
|
|
export type TaskFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Task to fetch.
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Tasks to fetch.
|
|
*/
|
|
orderBy?: TaskOrderByWithRelationInput | TaskOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Tasks.
|
|
*/
|
|
cursor?: TaskWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Tasks from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Tasks.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Tasks.
|
|
*/
|
|
distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Task findMany
|
|
*/
|
|
export type TaskFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Tasks to fetch.
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Tasks to fetch.
|
|
*/
|
|
orderBy?: TaskOrderByWithRelationInput | TaskOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Tasks.
|
|
*/
|
|
cursor?: TaskWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Tasks from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Tasks.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Tasks.
|
|
*/
|
|
distinct?: TaskScalarFieldEnum | TaskScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Task create
|
|
*/
|
|
export type TaskCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Task.
|
|
*/
|
|
data: XOR<TaskCreateInput, TaskUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Task createMany
|
|
*/
|
|
export type TaskCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Tasks.
|
|
*/
|
|
data: TaskCreateManyInput | TaskCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Task createManyAndReturn
|
|
*/
|
|
export type TaskCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Tasks.
|
|
*/
|
|
data: TaskCreateManyInput | TaskCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Task update
|
|
*/
|
|
export type TaskUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Task.
|
|
*/
|
|
data: XOR<TaskUpdateInput, TaskUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Task to update.
|
|
*/
|
|
where: TaskWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Task updateMany
|
|
*/
|
|
export type TaskUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Tasks.
|
|
*/
|
|
data: XOR<TaskUpdateManyMutationInput, TaskUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Tasks to update
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* Limit how many Tasks to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Task updateManyAndReturn
|
|
*/
|
|
export type TaskUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Tasks.
|
|
*/
|
|
data: XOR<TaskUpdateManyMutationInput, TaskUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Tasks to update
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* Limit how many Tasks to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Task upsert
|
|
*/
|
|
export type TaskUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Task to update in case it exists.
|
|
*/
|
|
where: TaskWhereUniqueInput
|
|
/**
|
|
* In case the Task found by the `where` argument doesn't exist, create a new Task with this data.
|
|
*/
|
|
create: XOR<TaskCreateInput, TaskUncheckedCreateInput>
|
|
/**
|
|
* In case the Task was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<TaskUpdateInput, TaskUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Task delete
|
|
*/
|
|
export type TaskDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Task to delete.
|
|
*/
|
|
where: TaskWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Task deleteMany
|
|
*/
|
|
export type TaskDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Tasks to delete
|
|
*/
|
|
where?: TaskWhereInput
|
|
/**
|
|
* Limit how many Tasks to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Task.claims
|
|
*/
|
|
export type Task$claimsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
where?: ClaimWhereInput
|
|
orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
|
|
cursor?: ClaimWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Task.submissions
|
|
*/
|
|
export type Task$submissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
where?: SubmissionWhereInput
|
|
orderBy?: SubmissionOrderByWithRelationInput | SubmissionOrderByWithRelationInput[]
|
|
cursor?: SubmissionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SubmissionScalarFieldEnum | SubmissionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Task without action
|
|
*/
|
|
export type TaskDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Task
|
|
*/
|
|
select?: TaskSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Task
|
|
*/
|
|
omit?: TaskOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: TaskInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Claim
|
|
*/
|
|
|
|
export type AggregateClaim = {
|
|
_count: ClaimCountAggregateOutputType | null
|
|
_avg: ClaimAvgAggregateOutputType | null
|
|
_sum: ClaimSumAggregateOutputType | null
|
|
_min: ClaimMinAggregateOutputType | null
|
|
_max: ClaimMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type ClaimAvgAggregateOutputType = {
|
|
held_amount: number | null
|
|
}
|
|
|
|
export type ClaimSumAggregateOutputType = {
|
|
held_amount: number | null
|
|
}
|
|
|
|
export type ClaimMinAggregateOutputType = {
|
|
id: string | null
|
|
task_id: string | null
|
|
developer_wallet: string | null
|
|
status: string | null
|
|
claim_token: string | null
|
|
held_amount: number | null
|
|
held_currency: string | null
|
|
expires_at: Date | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type ClaimMaxAggregateOutputType = {
|
|
id: string | null
|
|
task_id: string | null
|
|
developer_wallet: string | null
|
|
status: string | null
|
|
claim_token: string | null
|
|
held_amount: number | null
|
|
held_currency: string | null
|
|
expires_at: Date | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type ClaimCountAggregateOutputType = {
|
|
id: number
|
|
task_id: number
|
|
developer_wallet: number
|
|
status: number
|
|
claim_token: number
|
|
held_amount: number
|
|
held_currency: number
|
|
expires_at: number
|
|
created_at: number
|
|
updated_at: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type ClaimAvgAggregateInputType = {
|
|
held_amount?: true
|
|
}
|
|
|
|
export type ClaimSumAggregateInputType = {
|
|
held_amount?: true
|
|
}
|
|
|
|
export type ClaimMinAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
developer_wallet?: true
|
|
status?: true
|
|
claim_token?: true
|
|
held_amount?: true
|
|
held_currency?: true
|
|
expires_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type ClaimMaxAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
developer_wallet?: true
|
|
status?: true
|
|
claim_token?: true
|
|
held_amount?: true
|
|
held_currency?: true
|
|
expires_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type ClaimCountAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
developer_wallet?: true
|
|
status?: true
|
|
claim_token?: true
|
|
held_amount?: true
|
|
held_currency?: true
|
|
expires_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type ClaimAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Claim to aggregate.
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Claims to fetch.
|
|
*/
|
|
orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: ClaimWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Claims from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Claims.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Claims
|
|
**/
|
|
_count?: true | ClaimCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: ClaimAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: ClaimSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: ClaimMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: ClaimMaxAggregateInputType
|
|
}
|
|
|
|
export type GetClaimAggregateType<T extends ClaimAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateClaim]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateClaim[P]>
|
|
: GetScalarType<T[P], AggregateClaim[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type ClaimGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ClaimWhereInput
|
|
orderBy?: ClaimOrderByWithAggregationInput | ClaimOrderByWithAggregationInput[]
|
|
by: ClaimScalarFieldEnum[] | ClaimScalarFieldEnum
|
|
having?: ClaimScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: ClaimCountAggregateInputType | true
|
|
_avg?: ClaimAvgAggregateInputType
|
|
_sum?: ClaimSumAggregateInputType
|
|
_min?: ClaimMinAggregateInputType
|
|
_max?: ClaimMaxAggregateInputType
|
|
}
|
|
|
|
export type ClaimGroupByOutputType = {
|
|
id: string
|
|
task_id: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date
|
|
created_at: Date
|
|
updated_at: Date
|
|
_count: ClaimCountAggregateOutputType | null
|
|
_avg: ClaimAvgAggregateOutputType | null
|
|
_sum: ClaimSumAggregateOutputType | null
|
|
_min: ClaimMinAggregateOutputType | null
|
|
_max: ClaimMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetClaimGroupByPayload<T extends ClaimGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<ClaimGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof ClaimGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], ClaimGroupByOutputType[P]>
|
|
: GetScalarType<T[P], ClaimGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type ClaimSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
developer_wallet?: boolean
|
|
status?: boolean
|
|
claim_token?: boolean
|
|
held_amount?: boolean
|
|
held_currency?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
submissions?: boolean | Claim$submissionsArgs<ExtArgs>
|
|
_count?: boolean | ClaimCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["claim"]>
|
|
|
|
export type ClaimSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
developer_wallet?: boolean
|
|
status?: boolean
|
|
claim_token?: boolean
|
|
held_amount?: boolean
|
|
held_currency?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["claim"]>
|
|
|
|
export type ClaimSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
developer_wallet?: boolean
|
|
status?: boolean
|
|
claim_token?: boolean
|
|
held_amount?: boolean
|
|
held_currency?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["claim"]>
|
|
|
|
export type ClaimSelectScalar = {
|
|
id?: boolean
|
|
task_id?: boolean
|
|
developer_wallet?: boolean
|
|
status?: boolean
|
|
claim_token?: boolean
|
|
held_amount?: boolean
|
|
held_currency?: boolean
|
|
expires_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}
|
|
|
|
export type ClaimOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "task_id" | "developer_wallet" | "status" | "claim_token" | "held_amount" | "held_currency" | "expires_at" | "created_at" | "updated_at", ExtArgs["result"]["claim"]>
|
|
export type ClaimInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
submissions?: boolean | Claim$submissionsArgs<ExtArgs>
|
|
_count?: boolean | ClaimCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type ClaimIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
}
|
|
export type ClaimIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $ClaimPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Claim"
|
|
objects: {
|
|
task: Prisma.$TaskPayload<ExtArgs>
|
|
submissions: Prisma.$SubmissionPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
task_id: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date
|
|
created_at: Date
|
|
updated_at: Date
|
|
}, ExtArgs["result"]["claim"]>
|
|
composites: {}
|
|
}
|
|
|
|
type ClaimGetPayload<S extends boolean | null | undefined | ClaimDefaultArgs> = $Result.GetResult<Prisma.$ClaimPayload, S>
|
|
|
|
type ClaimCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<ClaimFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: ClaimCountAggregateInputType | true
|
|
}
|
|
|
|
export interface ClaimDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Claim'], meta: { name: 'Claim' } }
|
|
/**
|
|
* Find zero or one Claim that matches the filter.
|
|
* @param {ClaimFindUniqueArgs} args - Arguments to find a Claim
|
|
* @example
|
|
* // Get one Claim
|
|
* const claim = await prisma.claim.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends ClaimFindUniqueArgs>(args: SelectSubset<T, ClaimFindUniqueArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Claim that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {ClaimFindUniqueOrThrowArgs} args - Arguments to find a Claim
|
|
* @example
|
|
* // Get one Claim
|
|
* const claim = await prisma.claim.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends ClaimFindUniqueOrThrowArgs>(args: SelectSubset<T, ClaimFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Claim 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 {ClaimFindFirstArgs} args - Arguments to find a Claim
|
|
* @example
|
|
* // Get one Claim
|
|
* const claim = await prisma.claim.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends ClaimFindFirstArgs>(args?: SelectSubset<T, ClaimFindFirstArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Claim 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 {ClaimFindFirstOrThrowArgs} args - Arguments to find a Claim
|
|
* @example
|
|
* // Get one Claim
|
|
* const claim = await prisma.claim.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends ClaimFindFirstOrThrowArgs>(args?: SelectSubset<T, ClaimFindFirstOrThrowArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Claims 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 {ClaimFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Claims
|
|
* const claims = await prisma.claim.findMany()
|
|
*
|
|
* // Get first 10 Claims
|
|
* const claims = await prisma.claim.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const claimWithIdOnly = await prisma.claim.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends ClaimFindManyArgs>(args?: SelectSubset<T, ClaimFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Claim.
|
|
* @param {ClaimCreateArgs} args - Arguments to create a Claim.
|
|
* @example
|
|
* // Create one Claim
|
|
* const Claim = await prisma.claim.create({
|
|
* data: {
|
|
* // ... data to create a Claim
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends ClaimCreateArgs>(args: SelectSubset<T, ClaimCreateArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Claims.
|
|
* @param {ClaimCreateManyArgs} args - Arguments to create many Claims.
|
|
* @example
|
|
* // Create many Claims
|
|
* const claim = await prisma.claim.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends ClaimCreateManyArgs>(args?: SelectSubset<T, ClaimCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Claims and returns the data saved in the database.
|
|
* @param {ClaimCreateManyAndReturnArgs} args - Arguments to create many Claims.
|
|
* @example
|
|
* // Create many Claims
|
|
* const claim = await prisma.claim.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Claims and only return the `id`
|
|
* const claimWithIdOnly = await prisma.claim.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends ClaimCreateManyAndReturnArgs>(args?: SelectSubset<T, ClaimCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Claim.
|
|
* @param {ClaimDeleteArgs} args - Arguments to delete one Claim.
|
|
* @example
|
|
* // Delete one Claim
|
|
* const Claim = await prisma.claim.delete({
|
|
* where: {
|
|
* // ... filter to delete one Claim
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends ClaimDeleteArgs>(args: SelectSubset<T, ClaimDeleteArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Claim.
|
|
* @param {ClaimUpdateArgs} args - Arguments to update one Claim.
|
|
* @example
|
|
* // Update one Claim
|
|
* const claim = await prisma.claim.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends ClaimUpdateArgs>(args: SelectSubset<T, ClaimUpdateArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Claims.
|
|
* @param {ClaimDeleteManyArgs} args - Arguments to filter Claims to delete.
|
|
* @example
|
|
* // Delete a few Claims
|
|
* const { count } = await prisma.claim.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends ClaimDeleteManyArgs>(args?: SelectSubset<T, ClaimDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Claims.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ClaimUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Claims
|
|
* const claim = await prisma.claim.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends ClaimUpdateManyArgs>(args: SelectSubset<T, ClaimUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Claims and returns the data updated in the database.
|
|
* @param {ClaimUpdateManyAndReturnArgs} args - Arguments to update many Claims.
|
|
* @example
|
|
* // Update many Claims
|
|
* const claim = await prisma.claim.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Claims and only return the `id`
|
|
* const claimWithIdOnly = await prisma.claim.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends ClaimUpdateManyAndReturnArgs>(args: SelectSubset<T, ClaimUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Claim.
|
|
* @param {ClaimUpsertArgs} args - Arguments to update or create a Claim.
|
|
* @example
|
|
* // Update or create a Claim
|
|
* const claim = await prisma.claim.upsert({
|
|
* create: {
|
|
* // ... data to create a Claim
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Claim we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends ClaimUpsertArgs>(args: SelectSubset<T, ClaimUpsertArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Claims.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ClaimCountArgs} args - Arguments to filter Claims to count.
|
|
* @example
|
|
* // Count the number of Claims
|
|
* const count = await prisma.claim.count({
|
|
* where: {
|
|
* // ... the filter for the Claims we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends ClaimCountArgs>(
|
|
args?: Subset<T, ClaimCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], ClaimCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Claim.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ClaimAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends ClaimAggregateArgs>(args: Subset<T, ClaimAggregateArgs>): Prisma.PrismaPromise<GetClaimAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Claim.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ClaimGroupByArgs} 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 ClaimGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: ClaimGroupByArgs['orderBy'] }
|
|
: { orderBy?: ClaimGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, ClaimGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetClaimGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Claim model
|
|
*/
|
|
readonly fields: ClaimFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Claim.
|
|
* 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__ClaimClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
task<T extends TaskDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TaskDefaultArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
submissions<T extends Claim$submissionsArgs<ExtArgs> = {}>(args?: Subset<T, Claim$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the Claim model
|
|
*/
|
|
interface ClaimFieldRefs {
|
|
readonly id: FieldRef<"Claim", 'String'>
|
|
readonly task_id: FieldRef<"Claim", 'String'>
|
|
readonly developer_wallet: FieldRef<"Claim", 'String'>
|
|
readonly status: FieldRef<"Claim", 'String'>
|
|
readonly claim_token: FieldRef<"Claim", 'String'>
|
|
readonly held_amount: FieldRef<"Claim", 'Int'>
|
|
readonly held_currency: FieldRef<"Claim", 'String'>
|
|
readonly expires_at: FieldRef<"Claim", 'DateTime'>
|
|
readonly created_at: FieldRef<"Claim", 'DateTime'>
|
|
readonly updated_at: FieldRef<"Claim", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Claim findUnique
|
|
*/
|
|
export type ClaimFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Claim to fetch.
|
|
*/
|
|
where: ClaimWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Claim findUniqueOrThrow
|
|
*/
|
|
export type ClaimFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Claim to fetch.
|
|
*/
|
|
where: ClaimWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Claim findFirst
|
|
*/
|
|
export type ClaimFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Claim to fetch.
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Claims to fetch.
|
|
*/
|
|
orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Claims.
|
|
*/
|
|
cursor?: ClaimWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Claims from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Claims.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Claims.
|
|
*/
|
|
distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Claim findFirstOrThrow
|
|
*/
|
|
export type ClaimFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Claim to fetch.
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Claims to fetch.
|
|
*/
|
|
orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Claims.
|
|
*/
|
|
cursor?: ClaimWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Claims from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Claims.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Claims.
|
|
*/
|
|
distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Claim findMany
|
|
*/
|
|
export type ClaimFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Claims to fetch.
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Claims to fetch.
|
|
*/
|
|
orderBy?: ClaimOrderByWithRelationInput | ClaimOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Claims.
|
|
*/
|
|
cursor?: ClaimWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Claims from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Claims.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Claims.
|
|
*/
|
|
distinct?: ClaimScalarFieldEnum | ClaimScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Claim create
|
|
*/
|
|
export type ClaimCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Claim.
|
|
*/
|
|
data: XOR<ClaimCreateInput, ClaimUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Claim createMany
|
|
*/
|
|
export type ClaimCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Claims.
|
|
*/
|
|
data: ClaimCreateManyInput | ClaimCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Claim createManyAndReturn
|
|
*/
|
|
export type ClaimCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Claims.
|
|
*/
|
|
data: ClaimCreateManyInput | ClaimCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Claim update
|
|
*/
|
|
export type ClaimUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Claim.
|
|
*/
|
|
data: XOR<ClaimUpdateInput, ClaimUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Claim to update.
|
|
*/
|
|
where: ClaimWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Claim updateMany
|
|
*/
|
|
export type ClaimUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Claims.
|
|
*/
|
|
data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Claims to update
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* Limit how many Claims to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Claim updateManyAndReturn
|
|
*/
|
|
export type ClaimUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Claims.
|
|
*/
|
|
data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Claims to update
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* Limit how many Claims to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Claim upsert
|
|
*/
|
|
export type ClaimUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Claim to update in case it exists.
|
|
*/
|
|
where: ClaimWhereUniqueInput
|
|
/**
|
|
* In case the Claim found by the `where` argument doesn't exist, create a new Claim with this data.
|
|
*/
|
|
create: XOR<ClaimCreateInput, ClaimUncheckedCreateInput>
|
|
/**
|
|
* In case the Claim was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<ClaimUpdateInput, ClaimUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Claim delete
|
|
*/
|
|
export type ClaimDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Claim to delete.
|
|
*/
|
|
where: ClaimWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Claim deleteMany
|
|
*/
|
|
export type ClaimDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Claims to delete
|
|
*/
|
|
where?: ClaimWhereInput
|
|
/**
|
|
* Limit how many Claims to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Claim.submissions
|
|
*/
|
|
export type Claim$submissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
where?: SubmissionWhereInput
|
|
orderBy?: SubmissionOrderByWithRelationInput | SubmissionOrderByWithRelationInput[]
|
|
cursor?: SubmissionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SubmissionScalarFieldEnum | SubmissionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Claim without action
|
|
*/
|
|
export type ClaimDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Claim
|
|
*/
|
|
select?: ClaimSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Claim
|
|
*/
|
|
omit?: ClaimOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ClaimInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Submission
|
|
*/
|
|
|
|
export type AggregateSubmission = {
|
|
_count: SubmissionCountAggregateOutputType | null
|
|
_min: SubmissionMinAggregateOutputType | null
|
|
_max: SubmissionMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type SubmissionMinAggregateOutputType = {
|
|
id: string | null
|
|
task_id: string | null
|
|
claim_id: string | null
|
|
status: string | null
|
|
estimated_judge_complete_at: Date | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type SubmissionMaxAggregateOutputType = {
|
|
id: string | null
|
|
task_id: string | null
|
|
claim_id: string | null
|
|
status: string | null
|
|
estimated_judge_complete_at: Date | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type SubmissionCountAggregateOutputType = {
|
|
id: number
|
|
task_id: number
|
|
claim_id: number
|
|
status: number
|
|
deliverables: number
|
|
estimated_judge_complete_at: number
|
|
created_at: number
|
|
updated_at: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type SubmissionMinAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
claim_id?: true
|
|
status?: true
|
|
estimated_judge_complete_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type SubmissionMaxAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
claim_id?: true
|
|
status?: true
|
|
estimated_judge_complete_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type SubmissionCountAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
claim_id?: true
|
|
status?: true
|
|
deliverables?: true
|
|
estimated_judge_complete_at?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type SubmissionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Submission to aggregate.
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Submissions to fetch.
|
|
*/
|
|
orderBy?: SubmissionOrderByWithRelationInput | SubmissionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: SubmissionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Submissions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Submissions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Submissions
|
|
**/
|
|
_count?: true | SubmissionCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: SubmissionMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: SubmissionMaxAggregateInputType
|
|
}
|
|
|
|
export type GetSubmissionAggregateType<T extends SubmissionAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateSubmission]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateSubmission[P]>
|
|
: GetScalarType<T[P], AggregateSubmission[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type SubmissionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SubmissionWhereInput
|
|
orderBy?: SubmissionOrderByWithAggregationInput | SubmissionOrderByWithAggregationInput[]
|
|
by: SubmissionScalarFieldEnum[] | SubmissionScalarFieldEnum
|
|
having?: SubmissionScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: SubmissionCountAggregateInputType | true
|
|
_min?: SubmissionMinAggregateInputType
|
|
_max?: SubmissionMaxAggregateInputType
|
|
}
|
|
|
|
export type SubmissionGroupByOutputType = {
|
|
id: string
|
|
task_id: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: JsonValue
|
|
estimated_judge_complete_at: Date | null
|
|
created_at: Date
|
|
updated_at: Date
|
|
_count: SubmissionCountAggregateOutputType | null
|
|
_min: SubmissionMinAggregateOutputType | null
|
|
_max: SubmissionMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetSubmissionGroupByPayload<T extends SubmissionGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<SubmissionGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof SubmissionGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], SubmissionGroupByOutputType[P]>
|
|
: GetScalarType<T[P], SubmissionGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type SubmissionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
claim_id?: boolean
|
|
status?: boolean
|
|
deliverables?: boolean
|
|
estimated_judge_complete_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
claim?: boolean | ClaimDefaultArgs<ExtArgs>
|
|
judge_results?: boolean | Submission$judge_resultsArgs<ExtArgs>
|
|
_count?: boolean | SubmissionCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["submission"]>
|
|
|
|
export type SubmissionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
claim_id?: boolean
|
|
status?: boolean
|
|
deliverables?: boolean
|
|
estimated_judge_complete_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
claim?: boolean | ClaimDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["submission"]>
|
|
|
|
export type SubmissionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
claim_id?: boolean
|
|
status?: boolean
|
|
deliverables?: boolean
|
|
estimated_judge_complete_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
claim?: boolean | ClaimDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["submission"]>
|
|
|
|
export type SubmissionSelectScalar = {
|
|
id?: boolean
|
|
task_id?: boolean
|
|
claim_id?: boolean
|
|
status?: boolean
|
|
deliverables?: boolean
|
|
estimated_judge_complete_at?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}
|
|
|
|
export type SubmissionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "task_id" | "claim_id" | "status" | "deliverables" | "estimated_judge_complete_at" | "created_at" | "updated_at", ExtArgs["result"]["submission"]>
|
|
export type SubmissionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
claim?: boolean | ClaimDefaultArgs<ExtArgs>
|
|
judge_results?: boolean | Submission$judge_resultsArgs<ExtArgs>
|
|
_count?: boolean | SubmissionCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type SubmissionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
claim?: boolean | ClaimDefaultArgs<ExtArgs>
|
|
}
|
|
export type SubmissionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
task?: boolean | TaskDefaultArgs<ExtArgs>
|
|
claim?: boolean | ClaimDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $SubmissionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Submission"
|
|
objects: {
|
|
task: Prisma.$TaskPayload<ExtArgs>
|
|
claim: Prisma.$ClaimPayload<ExtArgs>
|
|
judge_results: Prisma.$JudgeResultPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
task_id: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: Prisma.JsonValue
|
|
estimated_judge_complete_at: Date | null
|
|
created_at: Date
|
|
updated_at: Date
|
|
}, ExtArgs["result"]["submission"]>
|
|
composites: {}
|
|
}
|
|
|
|
type SubmissionGetPayload<S extends boolean | null | undefined | SubmissionDefaultArgs> = $Result.GetResult<Prisma.$SubmissionPayload, S>
|
|
|
|
type SubmissionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<SubmissionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: SubmissionCountAggregateInputType | true
|
|
}
|
|
|
|
export interface SubmissionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Submission'], meta: { name: 'Submission' } }
|
|
/**
|
|
* Find zero or one Submission that matches the filter.
|
|
* @param {SubmissionFindUniqueArgs} args - Arguments to find a Submission
|
|
* @example
|
|
* // Get one Submission
|
|
* const submission = await prisma.submission.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends SubmissionFindUniqueArgs>(args: SelectSubset<T, SubmissionFindUniqueArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Submission that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {SubmissionFindUniqueOrThrowArgs} args - Arguments to find a Submission
|
|
* @example
|
|
* // Get one Submission
|
|
* const submission = await prisma.submission.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends SubmissionFindUniqueOrThrowArgs>(args: SelectSubset<T, SubmissionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Submission 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 {SubmissionFindFirstArgs} args - Arguments to find a Submission
|
|
* @example
|
|
* // Get one Submission
|
|
* const submission = await prisma.submission.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends SubmissionFindFirstArgs>(args?: SelectSubset<T, SubmissionFindFirstArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Submission 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 {SubmissionFindFirstOrThrowArgs} args - Arguments to find a Submission
|
|
* @example
|
|
* // Get one Submission
|
|
* const submission = await prisma.submission.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends SubmissionFindFirstOrThrowArgs>(args?: SelectSubset<T, SubmissionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Submissions 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 {SubmissionFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Submissions
|
|
* const submissions = await prisma.submission.findMany()
|
|
*
|
|
* // Get first 10 Submissions
|
|
* const submissions = await prisma.submission.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const submissionWithIdOnly = await prisma.submission.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends SubmissionFindManyArgs>(args?: SelectSubset<T, SubmissionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Submission.
|
|
* @param {SubmissionCreateArgs} args - Arguments to create a Submission.
|
|
* @example
|
|
* // Create one Submission
|
|
* const Submission = await prisma.submission.create({
|
|
* data: {
|
|
* // ... data to create a Submission
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends SubmissionCreateArgs>(args: SelectSubset<T, SubmissionCreateArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Submissions.
|
|
* @param {SubmissionCreateManyArgs} args - Arguments to create many Submissions.
|
|
* @example
|
|
* // Create many Submissions
|
|
* const submission = await prisma.submission.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends SubmissionCreateManyArgs>(args?: SelectSubset<T, SubmissionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Submissions and returns the data saved in the database.
|
|
* @param {SubmissionCreateManyAndReturnArgs} args - Arguments to create many Submissions.
|
|
* @example
|
|
* // Create many Submissions
|
|
* const submission = await prisma.submission.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Submissions and only return the `id`
|
|
* const submissionWithIdOnly = await prisma.submission.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends SubmissionCreateManyAndReturnArgs>(args?: SelectSubset<T, SubmissionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Submission.
|
|
* @param {SubmissionDeleteArgs} args - Arguments to delete one Submission.
|
|
* @example
|
|
* // Delete one Submission
|
|
* const Submission = await prisma.submission.delete({
|
|
* where: {
|
|
* // ... filter to delete one Submission
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends SubmissionDeleteArgs>(args: SelectSubset<T, SubmissionDeleteArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Submission.
|
|
* @param {SubmissionUpdateArgs} args - Arguments to update one Submission.
|
|
* @example
|
|
* // Update one Submission
|
|
* const submission = await prisma.submission.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends SubmissionUpdateArgs>(args: SelectSubset<T, SubmissionUpdateArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Submissions.
|
|
* @param {SubmissionDeleteManyArgs} args - Arguments to filter Submissions to delete.
|
|
* @example
|
|
* // Delete a few Submissions
|
|
* const { count } = await prisma.submission.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends SubmissionDeleteManyArgs>(args?: SelectSubset<T, SubmissionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Submissions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SubmissionUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Submissions
|
|
* const submission = await prisma.submission.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends SubmissionUpdateManyArgs>(args: SelectSubset<T, SubmissionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Submissions and returns the data updated in the database.
|
|
* @param {SubmissionUpdateManyAndReturnArgs} args - Arguments to update many Submissions.
|
|
* @example
|
|
* // Update many Submissions
|
|
* const submission = await prisma.submission.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Submissions and only return the `id`
|
|
* const submissionWithIdOnly = await prisma.submission.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends SubmissionUpdateManyAndReturnArgs>(args: SelectSubset<T, SubmissionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Submission.
|
|
* @param {SubmissionUpsertArgs} args - Arguments to update or create a Submission.
|
|
* @example
|
|
* // Update or create a Submission
|
|
* const submission = await prisma.submission.upsert({
|
|
* create: {
|
|
* // ... data to create a Submission
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Submission we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends SubmissionUpsertArgs>(args: SelectSubset<T, SubmissionUpsertArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Submissions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SubmissionCountArgs} args - Arguments to filter Submissions to count.
|
|
* @example
|
|
* // Count the number of Submissions
|
|
* const count = await prisma.submission.count({
|
|
* where: {
|
|
* // ... the filter for the Submissions we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends SubmissionCountArgs>(
|
|
args?: Subset<T, SubmissionCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], SubmissionCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Submission.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SubmissionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends SubmissionAggregateArgs>(args: Subset<T, SubmissionAggregateArgs>): Prisma.PrismaPromise<GetSubmissionAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Submission.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SubmissionGroupByArgs} 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 SubmissionGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: SubmissionGroupByArgs['orderBy'] }
|
|
: { orderBy?: SubmissionGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, SubmissionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSubmissionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Submission model
|
|
*/
|
|
readonly fields: SubmissionFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Submission.
|
|
* 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__SubmissionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
task<T extends TaskDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TaskDefaultArgs<ExtArgs>>): Prisma__TaskClient<$Result.GetResult<Prisma.$TaskPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
claim<T extends ClaimDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ClaimDefaultArgs<ExtArgs>>): Prisma__ClaimClient<$Result.GetResult<Prisma.$ClaimPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
judge_results<T extends Submission$judge_resultsArgs<ExtArgs> = {}>(args?: Subset<T, Submission$judge_resultsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the Submission model
|
|
*/
|
|
interface SubmissionFieldRefs {
|
|
readonly id: FieldRef<"Submission", 'String'>
|
|
readonly task_id: FieldRef<"Submission", 'String'>
|
|
readonly claim_id: FieldRef<"Submission", 'String'>
|
|
readonly status: FieldRef<"Submission", 'String'>
|
|
readonly deliverables: FieldRef<"Submission", 'Json'>
|
|
readonly estimated_judge_complete_at: FieldRef<"Submission", 'DateTime'>
|
|
readonly created_at: FieldRef<"Submission", 'DateTime'>
|
|
readonly updated_at: FieldRef<"Submission", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Submission findUnique
|
|
*/
|
|
export type SubmissionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Submission to fetch.
|
|
*/
|
|
where: SubmissionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Submission findUniqueOrThrow
|
|
*/
|
|
export type SubmissionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Submission to fetch.
|
|
*/
|
|
where: SubmissionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Submission findFirst
|
|
*/
|
|
export type SubmissionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Submission to fetch.
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Submissions to fetch.
|
|
*/
|
|
orderBy?: SubmissionOrderByWithRelationInput | SubmissionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Submissions.
|
|
*/
|
|
cursor?: SubmissionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Submissions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Submissions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Submissions.
|
|
*/
|
|
distinct?: SubmissionScalarFieldEnum | SubmissionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Submission findFirstOrThrow
|
|
*/
|
|
export type SubmissionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Submission to fetch.
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Submissions to fetch.
|
|
*/
|
|
orderBy?: SubmissionOrderByWithRelationInput | SubmissionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Submissions.
|
|
*/
|
|
cursor?: SubmissionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Submissions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Submissions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Submissions.
|
|
*/
|
|
distinct?: SubmissionScalarFieldEnum | SubmissionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Submission findMany
|
|
*/
|
|
export type SubmissionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Submissions to fetch.
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Submissions to fetch.
|
|
*/
|
|
orderBy?: SubmissionOrderByWithRelationInput | SubmissionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Submissions.
|
|
*/
|
|
cursor?: SubmissionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Submissions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Submissions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Submissions.
|
|
*/
|
|
distinct?: SubmissionScalarFieldEnum | SubmissionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Submission create
|
|
*/
|
|
export type SubmissionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Submission.
|
|
*/
|
|
data: XOR<SubmissionCreateInput, SubmissionUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Submission createMany
|
|
*/
|
|
export type SubmissionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Submissions.
|
|
*/
|
|
data: SubmissionCreateManyInput | SubmissionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Submission createManyAndReturn
|
|
*/
|
|
export type SubmissionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Submissions.
|
|
*/
|
|
data: SubmissionCreateManyInput | SubmissionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Submission update
|
|
*/
|
|
export type SubmissionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Submission.
|
|
*/
|
|
data: XOR<SubmissionUpdateInput, SubmissionUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Submission to update.
|
|
*/
|
|
where: SubmissionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Submission updateMany
|
|
*/
|
|
export type SubmissionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Submissions.
|
|
*/
|
|
data: XOR<SubmissionUpdateManyMutationInput, SubmissionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Submissions to update
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* Limit how many Submissions to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Submission updateManyAndReturn
|
|
*/
|
|
export type SubmissionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Submissions.
|
|
*/
|
|
data: XOR<SubmissionUpdateManyMutationInput, SubmissionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Submissions to update
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* Limit how many Submissions to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Submission upsert
|
|
*/
|
|
export type SubmissionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Submission to update in case it exists.
|
|
*/
|
|
where: SubmissionWhereUniqueInput
|
|
/**
|
|
* In case the Submission found by the `where` argument doesn't exist, create a new Submission with this data.
|
|
*/
|
|
create: XOR<SubmissionCreateInput, SubmissionUncheckedCreateInput>
|
|
/**
|
|
* In case the Submission was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<SubmissionUpdateInput, SubmissionUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Submission delete
|
|
*/
|
|
export type SubmissionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Submission to delete.
|
|
*/
|
|
where: SubmissionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Submission deleteMany
|
|
*/
|
|
export type SubmissionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Submissions to delete
|
|
*/
|
|
where?: SubmissionWhereInput
|
|
/**
|
|
* Limit how many Submissions to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Submission.judge_results
|
|
*/
|
|
export type Submission$judge_resultsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
where?: JudgeResultWhereInput
|
|
orderBy?: JudgeResultOrderByWithRelationInput | JudgeResultOrderByWithRelationInput[]
|
|
cursor?: JudgeResultWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: JudgeResultScalarFieldEnum | JudgeResultScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Submission without action
|
|
*/
|
|
export type SubmissionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Submission
|
|
*/
|
|
select?: SubmissionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Submission
|
|
*/
|
|
omit?: SubmissionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SubmissionInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model JudgeResult
|
|
*/
|
|
|
|
export type AggregateJudgeResult = {
|
|
_count: JudgeResultCountAggregateOutputType | null
|
|
_min: JudgeResultMinAggregateOutputType | null
|
|
_max: JudgeResultMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type JudgeResultMinAggregateOutputType = {
|
|
id: string | null
|
|
submission_id: string | null
|
|
overall_result: string | null
|
|
error_classification: string | null
|
|
error_signature: string | null
|
|
retryable: boolean | null
|
|
judge_completed_at: Date | null
|
|
}
|
|
|
|
export type JudgeResultMaxAggregateOutputType = {
|
|
id: string | null
|
|
submission_id: string | null
|
|
overall_result: string | null
|
|
error_classification: string | null
|
|
error_signature: string | null
|
|
retryable: boolean | null
|
|
judge_completed_at: Date | null
|
|
}
|
|
|
|
export type JudgeResultCountAggregateOutputType = {
|
|
id: number
|
|
submission_id: number
|
|
overall_result: number
|
|
tests: number
|
|
artifacts: number
|
|
error_classification: number
|
|
error_signature: number
|
|
retryable: number
|
|
resource_usage: number
|
|
judge_completed_at: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type JudgeResultMinAggregateInputType = {
|
|
id?: true
|
|
submission_id?: true
|
|
overall_result?: true
|
|
error_classification?: true
|
|
error_signature?: true
|
|
retryable?: true
|
|
judge_completed_at?: true
|
|
}
|
|
|
|
export type JudgeResultMaxAggregateInputType = {
|
|
id?: true
|
|
submission_id?: true
|
|
overall_result?: true
|
|
error_classification?: true
|
|
error_signature?: true
|
|
retryable?: true
|
|
judge_completed_at?: true
|
|
}
|
|
|
|
export type JudgeResultCountAggregateInputType = {
|
|
id?: true
|
|
submission_id?: true
|
|
overall_result?: true
|
|
tests?: true
|
|
artifacts?: true
|
|
error_classification?: true
|
|
error_signature?: true
|
|
retryable?: true
|
|
resource_usage?: true
|
|
judge_completed_at?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type JudgeResultAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which JudgeResult to aggregate.
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of JudgeResults to fetch.
|
|
*/
|
|
orderBy?: JudgeResultOrderByWithRelationInput | JudgeResultOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: JudgeResultWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` JudgeResults from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` JudgeResults.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned JudgeResults
|
|
**/
|
|
_count?: true | JudgeResultCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: JudgeResultMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: JudgeResultMaxAggregateInputType
|
|
}
|
|
|
|
export type GetJudgeResultAggregateType<T extends JudgeResultAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateJudgeResult]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateJudgeResult[P]>
|
|
: GetScalarType<T[P], AggregateJudgeResult[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type JudgeResultGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: JudgeResultWhereInput
|
|
orderBy?: JudgeResultOrderByWithAggregationInput | JudgeResultOrderByWithAggregationInput[]
|
|
by: JudgeResultScalarFieldEnum[] | JudgeResultScalarFieldEnum
|
|
having?: JudgeResultScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: JudgeResultCountAggregateInputType | true
|
|
_min?: JudgeResultMinAggregateInputType
|
|
_max?: JudgeResultMaxAggregateInputType
|
|
}
|
|
|
|
export type JudgeResultGroupByOutputType = {
|
|
id: string
|
|
submission_id: string
|
|
overall_result: string
|
|
tests: JsonValue
|
|
artifacts: JsonValue | null
|
|
error_classification: string | null
|
|
error_signature: string | null
|
|
retryable: boolean
|
|
resource_usage: JsonValue
|
|
judge_completed_at: Date
|
|
_count: JudgeResultCountAggregateOutputType | null
|
|
_min: JudgeResultMinAggregateOutputType | null
|
|
_max: JudgeResultMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetJudgeResultGroupByPayload<T extends JudgeResultGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<JudgeResultGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof JudgeResultGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], JudgeResultGroupByOutputType[P]>
|
|
: GetScalarType<T[P], JudgeResultGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type JudgeResultSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
submission_id?: boolean
|
|
overall_result?: boolean
|
|
tests?: boolean
|
|
artifacts?: boolean
|
|
error_classification?: boolean
|
|
error_signature?: boolean
|
|
retryable?: boolean
|
|
resource_usage?: boolean
|
|
judge_completed_at?: boolean
|
|
submission?: boolean | SubmissionDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["judgeResult"]>
|
|
|
|
export type JudgeResultSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
submission_id?: boolean
|
|
overall_result?: boolean
|
|
tests?: boolean
|
|
artifacts?: boolean
|
|
error_classification?: boolean
|
|
error_signature?: boolean
|
|
retryable?: boolean
|
|
resource_usage?: boolean
|
|
judge_completed_at?: boolean
|
|
submission?: boolean | SubmissionDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["judgeResult"]>
|
|
|
|
export type JudgeResultSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
submission_id?: boolean
|
|
overall_result?: boolean
|
|
tests?: boolean
|
|
artifacts?: boolean
|
|
error_classification?: boolean
|
|
error_signature?: boolean
|
|
retryable?: boolean
|
|
resource_usage?: boolean
|
|
judge_completed_at?: boolean
|
|
submission?: boolean | SubmissionDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["judgeResult"]>
|
|
|
|
export type JudgeResultSelectScalar = {
|
|
id?: boolean
|
|
submission_id?: boolean
|
|
overall_result?: boolean
|
|
tests?: boolean
|
|
artifacts?: boolean
|
|
error_classification?: boolean
|
|
error_signature?: boolean
|
|
retryable?: boolean
|
|
resource_usage?: boolean
|
|
judge_completed_at?: boolean
|
|
}
|
|
|
|
export type JudgeResultOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "submission_id" | "overall_result" | "tests" | "artifacts" | "error_classification" | "error_signature" | "retryable" | "resource_usage" | "judge_completed_at", ExtArgs["result"]["judgeResult"]>
|
|
export type JudgeResultInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
submission?: boolean | SubmissionDefaultArgs<ExtArgs>
|
|
}
|
|
export type JudgeResultIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
submission?: boolean | SubmissionDefaultArgs<ExtArgs>
|
|
}
|
|
export type JudgeResultIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
submission?: boolean | SubmissionDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $JudgeResultPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "JudgeResult"
|
|
objects: {
|
|
submission: Prisma.$SubmissionPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
submission_id: string
|
|
overall_result: string
|
|
tests: Prisma.JsonValue
|
|
artifacts: Prisma.JsonValue | null
|
|
error_classification: string | null
|
|
error_signature: string | null
|
|
retryable: boolean
|
|
resource_usage: Prisma.JsonValue
|
|
judge_completed_at: Date
|
|
}, ExtArgs["result"]["judgeResult"]>
|
|
composites: {}
|
|
}
|
|
|
|
type JudgeResultGetPayload<S extends boolean | null | undefined | JudgeResultDefaultArgs> = $Result.GetResult<Prisma.$JudgeResultPayload, S>
|
|
|
|
type JudgeResultCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<JudgeResultFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: JudgeResultCountAggregateInputType | true
|
|
}
|
|
|
|
export interface JudgeResultDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['JudgeResult'], meta: { name: 'JudgeResult' } }
|
|
/**
|
|
* Find zero or one JudgeResult that matches the filter.
|
|
* @param {JudgeResultFindUniqueArgs} args - Arguments to find a JudgeResult
|
|
* @example
|
|
* // Get one JudgeResult
|
|
* const judgeResult = await prisma.judgeResult.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends JudgeResultFindUniqueArgs>(args: SelectSubset<T, JudgeResultFindUniqueArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one JudgeResult that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {JudgeResultFindUniqueOrThrowArgs} args - Arguments to find a JudgeResult
|
|
* @example
|
|
* // Get one JudgeResult
|
|
* const judgeResult = await prisma.judgeResult.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends JudgeResultFindUniqueOrThrowArgs>(args: SelectSubset<T, JudgeResultFindUniqueOrThrowArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first JudgeResult 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 {JudgeResultFindFirstArgs} args - Arguments to find a JudgeResult
|
|
* @example
|
|
* // Get one JudgeResult
|
|
* const judgeResult = await prisma.judgeResult.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends JudgeResultFindFirstArgs>(args?: SelectSubset<T, JudgeResultFindFirstArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first JudgeResult 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 {JudgeResultFindFirstOrThrowArgs} args - Arguments to find a JudgeResult
|
|
* @example
|
|
* // Get one JudgeResult
|
|
* const judgeResult = await prisma.judgeResult.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends JudgeResultFindFirstOrThrowArgs>(args?: SelectSubset<T, JudgeResultFindFirstOrThrowArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more JudgeResults 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 {JudgeResultFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all JudgeResults
|
|
* const judgeResults = await prisma.judgeResult.findMany()
|
|
*
|
|
* // Get first 10 JudgeResults
|
|
* const judgeResults = await prisma.judgeResult.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const judgeResultWithIdOnly = await prisma.judgeResult.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends JudgeResultFindManyArgs>(args?: SelectSubset<T, JudgeResultFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a JudgeResult.
|
|
* @param {JudgeResultCreateArgs} args - Arguments to create a JudgeResult.
|
|
* @example
|
|
* // Create one JudgeResult
|
|
* const JudgeResult = await prisma.judgeResult.create({
|
|
* data: {
|
|
* // ... data to create a JudgeResult
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends JudgeResultCreateArgs>(args: SelectSubset<T, JudgeResultCreateArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many JudgeResults.
|
|
* @param {JudgeResultCreateManyArgs} args - Arguments to create many JudgeResults.
|
|
* @example
|
|
* // Create many JudgeResults
|
|
* const judgeResult = await prisma.judgeResult.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends JudgeResultCreateManyArgs>(args?: SelectSubset<T, JudgeResultCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many JudgeResults and returns the data saved in the database.
|
|
* @param {JudgeResultCreateManyAndReturnArgs} args - Arguments to create many JudgeResults.
|
|
* @example
|
|
* // Create many JudgeResults
|
|
* const judgeResult = await prisma.judgeResult.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many JudgeResults and only return the `id`
|
|
* const judgeResultWithIdOnly = await prisma.judgeResult.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends JudgeResultCreateManyAndReturnArgs>(args?: SelectSubset<T, JudgeResultCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a JudgeResult.
|
|
* @param {JudgeResultDeleteArgs} args - Arguments to delete one JudgeResult.
|
|
* @example
|
|
* // Delete one JudgeResult
|
|
* const JudgeResult = await prisma.judgeResult.delete({
|
|
* where: {
|
|
* // ... filter to delete one JudgeResult
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends JudgeResultDeleteArgs>(args: SelectSubset<T, JudgeResultDeleteArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one JudgeResult.
|
|
* @param {JudgeResultUpdateArgs} args - Arguments to update one JudgeResult.
|
|
* @example
|
|
* // Update one JudgeResult
|
|
* const judgeResult = await prisma.judgeResult.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends JudgeResultUpdateArgs>(args: SelectSubset<T, JudgeResultUpdateArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more JudgeResults.
|
|
* @param {JudgeResultDeleteManyArgs} args - Arguments to filter JudgeResults to delete.
|
|
* @example
|
|
* // Delete a few JudgeResults
|
|
* const { count } = await prisma.judgeResult.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends JudgeResultDeleteManyArgs>(args?: SelectSubset<T, JudgeResultDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more JudgeResults.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {JudgeResultUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many JudgeResults
|
|
* const judgeResult = await prisma.judgeResult.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends JudgeResultUpdateManyArgs>(args: SelectSubset<T, JudgeResultUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more JudgeResults and returns the data updated in the database.
|
|
* @param {JudgeResultUpdateManyAndReturnArgs} args - Arguments to update many JudgeResults.
|
|
* @example
|
|
* // Update many JudgeResults
|
|
* const judgeResult = await prisma.judgeResult.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more JudgeResults and only return the `id`
|
|
* const judgeResultWithIdOnly = await prisma.judgeResult.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends JudgeResultUpdateManyAndReturnArgs>(args: SelectSubset<T, JudgeResultUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one JudgeResult.
|
|
* @param {JudgeResultUpsertArgs} args - Arguments to update or create a JudgeResult.
|
|
* @example
|
|
* // Update or create a JudgeResult
|
|
* const judgeResult = await prisma.judgeResult.upsert({
|
|
* create: {
|
|
* // ... data to create a JudgeResult
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the JudgeResult we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends JudgeResultUpsertArgs>(args: SelectSubset<T, JudgeResultUpsertArgs<ExtArgs>>): Prisma__JudgeResultClient<$Result.GetResult<Prisma.$JudgeResultPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of JudgeResults.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {JudgeResultCountArgs} args - Arguments to filter JudgeResults to count.
|
|
* @example
|
|
* // Count the number of JudgeResults
|
|
* const count = await prisma.judgeResult.count({
|
|
* where: {
|
|
* // ... the filter for the JudgeResults we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends JudgeResultCountArgs>(
|
|
args?: Subset<T, JudgeResultCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], JudgeResultCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a JudgeResult.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {JudgeResultAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends JudgeResultAggregateArgs>(args: Subset<T, JudgeResultAggregateArgs>): Prisma.PrismaPromise<GetJudgeResultAggregateType<T>>
|
|
|
|
/**
|
|
* Group by JudgeResult.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {JudgeResultGroupByArgs} 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 JudgeResultGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: JudgeResultGroupByArgs['orderBy'] }
|
|
: { orderBy?: JudgeResultGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, JudgeResultGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetJudgeResultGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the JudgeResult model
|
|
*/
|
|
readonly fields: JudgeResultFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for JudgeResult.
|
|
* 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__JudgeResultClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
submission<T extends SubmissionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SubmissionDefaultArgs<ExtArgs>>): Prisma__SubmissionClient<$Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the JudgeResult model
|
|
*/
|
|
interface JudgeResultFieldRefs {
|
|
readonly id: FieldRef<"JudgeResult", 'String'>
|
|
readonly submission_id: FieldRef<"JudgeResult", 'String'>
|
|
readonly overall_result: FieldRef<"JudgeResult", 'String'>
|
|
readonly tests: FieldRef<"JudgeResult", 'Json'>
|
|
readonly artifacts: FieldRef<"JudgeResult", 'Json'>
|
|
readonly error_classification: FieldRef<"JudgeResult", 'String'>
|
|
readonly error_signature: FieldRef<"JudgeResult", 'String'>
|
|
readonly retryable: FieldRef<"JudgeResult", 'Boolean'>
|
|
readonly resource_usage: FieldRef<"JudgeResult", 'Json'>
|
|
readonly judge_completed_at: FieldRef<"JudgeResult", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* JudgeResult findUnique
|
|
*/
|
|
export type JudgeResultFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which JudgeResult to fetch.
|
|
*/
|
|
where: JudgeResultWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* JudgeResult findUniqueOrThrow
|
|
*/
|
|
export type JudgeResultFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which JudgeResult to fetch.
|
|
*/
|
|
where: JudgeResultWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* JudgeResult findFirst
|
|
*/
|
|
export type JudgeResultFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which JudgeResult to fetch.
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of JudgeResults to fetch.
|
|
*/
|
|
orderBy?: JudgeResultOrderByWithRelationInput | JudgeResultOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for JudgeResults.
|
|
*/
|
|
cursor?: JudgeResultWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` JudgeResults from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` JudgeResults.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of JudgeResults.
|
|
*/
|
|
distinct?: JudgeResultScalarFieldEnum | JudgeResultScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* JudgeResult findFirstOrThrow
|
|
*/
|
|
export type JudgeResultFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which JudgeResult to fetch.
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of JudgeResults to fetch.
|
|
*/
|
|
orderBy?: JudgeResultOrderByWithRelationInput | JudgeResultOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for JudgeResults.
|
|
*/
|
|
cursor?: JudgeResultWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` JudgeResults from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` JudgeResults.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of JudgeResults.
|
|
*/
|
|
distinct?: JudgeResultScalarFieldEnum | JudgeResultScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* JudgeResult findMany
|
|
*/
|
|
export type JudgeResultFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which JudgeResults to fetch.
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of JudgeResults to fetch.
|
|
*/
|
|
orderBy?: JudgeResultOrderByWithRelationInput | JudgeResultOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing JudgeResults.
|
|
*/
|
|
cursor?: JudgeResultWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` JudgeResults from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` JudgeResults.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of JudgeResults.
|
|
*/
|
|
distinct?: JudgeResultScalarFieldEnum | JudgeResultScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* JudgeResult create
|
|
*/
|
|
export type JudgeResultCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a JudgeResult.
|
|
*/
|
|
data: XOR<JudgeResultCreateInput, JudgeResultUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* JudgeResult createMany
|
|
*/
|
|
export type JudgeResultCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many JudgeResults.
|
|
*/
|
|
data: JudgeResultCreateManyInput | JudgeResultCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* JudgeResult createManyAndReturn
|
|
*/
|
|
export type JudgeResultCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many JudgeResults.
|
|
*/
|
|
data: JudgeResultCreateManyInput | JudgeResultCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* JudgeResult update
|
|
*/
|
|
export type JudgeResultUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a JudgeResult.
|
|
*/
|
|
data: XOR<JudgeResultUpdateInput, JudgeResultUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which JudgeResult to update.
|
|
*/
|
|
where: JudgeResultWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* JudgeResult updateMany
|
|
*/
|
|
export type JudgeResultUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update JudgeResults.
|
|
*/
|
|
data: XOR<JudgeResultUpdateManyMutationInput, JudgeResultUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which JudgeResults to update
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* Limit how many JudgeResults to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* JudgeResult updateManyAndReturn
|
|
*/
|
|
export type JudgeResultUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update JudgeResults.
|
|
*/
|
|
data: XOR<JudgeResultUpdateManyMutationInput, JudgeResultUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which JudgeResults to update
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* Limit how many JudgeResults to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* JudgeResult upsert
|
|
*/
|
|
export type JudgeResultUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the JudgeResult to update in case it exists.
|
|
*/
|
|
where: JudgeResultWhereUniqueInput
|
|
/**
|
|
* In case the JudgeResult found by the `where` argument doesn't exist, create a new JudgeResult with this data.
|
|
*/
|
|
create: XOR<JudgeResultCreateInput, JudgeResultUncheckedCreateInput>
|
|
/**
|
|
* In case the JudgeResult was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<JudgeResultUpdateInput, JudgeResultUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* JudgeResult delete
|
|
*/
|
|
export type JudgeResultDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which JudgeResult to delete.
|
|
*/
|
|
where: JudgeResultWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* JudgeResult deleteMany
|
|
*/
|
|
export type JudgeResultDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which JudgeResults to delete
|
|
*/
|
|
where?: JudgeResultWhereInput
|
|
/**
|
|
* Limit how many JudgeResults to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* JudgeResult without action
|
|
*/
|
|
export type JudgeResultDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the JudgeResult
|
|
*/
|
|
select?: JudgeResultSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the JudgeResult
|
|
*/
|
|
omit?: JudgeResultOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: JudgeResultInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model AuditEvent
|
|
*/
|
|
|
|
export type AggregateAuditEvent = {
|
|
_count: AuditEventCountAggregateOutputType | null
|
|
_min: AuditEventMinAggregateOutputType | null
|
|
_max: AuditEventMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type AuditEventMinAggregateOutputType = {
|
|
id: string | null
|
|
actorType: string | null
|
|
actorId: string | null
|
|
action: string | null
|
|
entityType: string | null
|
|
entityId: string | null
|
|
reason: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type AuditEventMaxAggregateOutputType = {
|
|
id: string | null
|
|
actorType: string | null
|
|
actorId: string | null
|
|
action: string | null
|
|
entityType: string | null
|
|
entityId: string | null
|
|
reason: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type AuditEventCountAggregateOutputType = {
|
|
id: number
|
|
actorType: number
|
|
actorId: number
|
|
action: number
|
|
entityType: number
|
|
entityId: number
|
|
beforeState: number
|
|
afterState: number
|
|
reason: number
|
|
metadata: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type AuditEventMinAggregateInputType = {
|
|
id?: true
|
|
actorType?: true
|
|
actorId?: true
|
|
action?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
reason?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type AuditEventMaxAggregateInputType = {
|
|
id?: true
|
|
actorType?: true
|
|
actorId?: true
|
|
action?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
reason?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type AuditEventCountAggregateInputType = {
|
|
id?: true
|
|
actorType?: true
|
|
actorId?: true
|
|
action?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
beforeState?: true
|
|
afterState?: true
|
|
reason?: true
|
|
metadata?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type AuditEventAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which AuditEvent to aggregate.
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AuditEvents to fetch.
|
|
*/
|
|
orderBy?: AuditEventOrderByWithRelationInput | AuditEventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: AuditEventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AuditEvents from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` AuditEvents.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned AuditEvents
|
|
**/
|
|
_count?: true | AuditEventCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: AuditEventMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: AuditEventMaxAggregateInputType
|
|
}
|
|
|
|
export type GetAuditEventAggregateType<T extends AuditEventAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateAuditEvent]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateAuditEvent[P]>
|
|
: GetScalarType<T[P], AggregateAuditEvent[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type AuditEventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AuditEventWhereInput
|
|
orderBy?: AuditEventOrderByWithAggregationInput | AuditEventOrderByWithAggregationInput[]
|
|
by: AuditEventScalarFieldEnum[] | AuditEventScalarFieldEnum
|
|
having?: AuditEventScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: AuditEventCountAggregateInputType | true
|
|
_min?: AuditEventMinAggregateInputType
|
|
_max?: AuditEventMaxAggregateInputType
|
|
}
|
|
|
|
export type AuditEventGroupByOutputType = {
|
|
id: string
|
|
actorType: string
|
|
actorId: string | null
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
beforeState: JsonValue | null
|
|
afterState: JsonValue | null
|
|
reason: string | null
|
|
metadata: JsonValue | null
|
|
createdAt: Date
|
|
_count: AuditEventCountAggregateOutputType | null
|
|
_min: AuditEventMinAggregateOutputType | null
|
|
_max: AuditEventMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetAuditEventGroupByPayload<T extends AuditEventGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<AuditEventGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof AuditEventGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], AuditEventGroupByOutputType[P]>
|
|
: GetScalarType<T[P], AuditEventGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type AuditEventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
actorType?: boolean
|
|
actorId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
beforeState?: boolean
|
|
afterState?: boolean
|
|
reason?: boolean
|
|
metadata?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["auditEvent"]>
|
|
|
|
export type AuditEventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
actorType?: boolean
|
|
actorId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
beforeState?: boolean
|
|
afterState?: boolean
|
|
reason?: boolean
|
|
metadata?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["auditEvent"]>
|
|
|
|
export type AuditEventSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
actorType?: boolean
|
|
actorId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
beforeState?: boolean
|
|
afterState?: boolean
|
|
reason?: boolean
|
|
metadata?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["auditEvent"]>
|
|
|
|
export type AuditEventSelectScalar = {
|
|
id?: boolean
|
|
actorType?: boolean
|
|
actorId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
beforeState?: boolean
|
|
afterState?: boolean
|
|
reason?: boolean
|
|
metadata?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type AuditEventOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "actorType" | "actorId" | "action" | "entityType" | "entityId" | "beforeState" | "afterState" | "reason" | "metadata" | "createdAt", ExtArgs["result"]["auditEvent"]>
|
|
|
|
export type $AuditEventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "AuditEvent"
|
|
objects: {}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
actorType: string
|
|
actorId: string | null
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
beforeState: Prisma.JsonValue | null
|
|
afterState: Prisma.JsonValue | null
|
|
reason: string | null
|
|
metadata: Prisma.JsonValue | null
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["auditEvent"]>
|
|
composites: {}
|
|
}
|
|
|
|
type AuditEventGetPayload<S extends boolean | null | undefined | AuditEventDefaultArgs> = $Result.GetResult<Prisma.$AuditEventPayload, S>
|
|
|
|
type AuditEventCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<AuditEventFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: AuditEventCountAggregateInputType | true
|
|
}
|
|
|
|
export interface AuditEventDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['AuditEvent'], meta: { name: 'AuditEvent' } }
|
|
/**
|
|
* Find zero or one AuditEvent that matches the filter.
|
|
* @param {AuditEventFindUniqueArgs} args - Arguments to find a AuditEvent
|
|
* @example
|
|
* // Get one AuditEvent
|
|
* const auditEvent = await prisma.auditEvent.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends AuditEventFindUniqueArgs>(args: SelectSubset<T, AuditEventFindUniqueArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one AuditEvent that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {AuditEventFindUniqueOrThrowArgs} args - Arguments to find a AuditEvent
|
|
* @example
|
|
* // Get one AuditEvent
|
|
* const auditEvent = await prisma.auditEvent.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends AuditEventFindUniqueOrThrowArgs>(args: SelectSubset<T, AuditEventFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first AuditEvent 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 {AuditEventFindFirstArgs} args - Arguments to find a AuditEvent
|
|
* @example
|
|
* // Get one AuditEvent
|
|
* const auditEvent = await prisma.auditEvent.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends AuditEventFindFirstArgs>(args?: SelectSubset<T, AuditEventFindFirstArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first AuditEvent 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 {AuditEventFindFirstOrThrowArgs} args - Arguments to find a AuditEvent
|
|
* @example
|
|
* // Get one AuditEvent
|
|
* const auditEvent = await prisma.auditEvent.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends AuditEventFindFirstOrThrowArgs>(args?: SelectSubset<T, AuditEventFindFirstOrThrowArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more AuditEvents 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 {AuditEventFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all AuditEvents
|
|
* const auditEvents = await prisma.auditEvent.findMany()
|
|
*
|
|
* // Get first 10 AuditEvents
|
|
* const auditEvents = await prisma.auditEvent.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const auditEventWithIdOnly = await prisma.auditEvent.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends AuditEventFindManyArgs>(args?: SelectSubset<T, AuditEventFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a AuditEvent.
|
|
* @param {AuditEventCreateArgs} args - Arguments to create a AuditEvent.
|
|
* @example
|
|
* // Create one AuditEvent
|
|
* const AuditEvent = await prisma.auditEvent.create({
|
|
* data: {
|
|
* // ... data to create a AuditEvent
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends AuditEventCreateArgs>(args: SelectSubset<T, AuditEventCreateArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many AuditEvents.
|
|
* @param {AuditEventCreateManyArgs} args - Arguments to create many AuditEvents.
|
|
* @example
|
|
* // Create many AuditEvents
|
|
* const auditEvent = await prisma.auditEvent.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends AuditEventCreateManyArgs>(args?: SelectSubset<T, AuditEventCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many AuditEvents and returns the data saved in the database.
|
|
* @param {AuditEventCreateManyAndReturnArgs} args - Arguments to create many AuditEvents.
|
|
* @example
|
|
* // Create many AuditEvents
|
|
* const auditEvent = await prisma.auditEvent.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many AuditEvents and only return the `id`
|
|
* const auditEventWithIdOnly = await prisma.auditEvent.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends AuditEventCreateManyAndReturnArgs>(args?: SelectSubset<T, AuditEventCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a AuditEvent.
|
|
* @param {AuditEventDeleteArgs} args - Arguments to delete one AuditEvent.
|
|
* @example
|
|
* // Delete one AuditEvent
|
|
* const AuditEvent = await prisma.auditEvent.delete({
|
|
* where: {
|
|
* // ... filter to delete one AuditEvent
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends AuditEventDeleteArgs>(args: SelectSubset<T, AuditEventDeleteArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one AuditEvent.
|
|
* @param {AuditEventUpdateArgs} args - Arguments to update one AuditEvent.
|
|
* @example
|
|
* // Update one AuditEvent
|
|
* const auditEvent = await prisma.auditEvent.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends AuditEventUpdateArgs>(args: SelectSubset<T, AuditEventUpdateArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more AuditEvents.
|
|
* @param {AuditEventDeleteManyArgs} args - Arguments to filter AuditEvents to delete.
|
|
* @example
|
|
* // Delete a few AuditEvents
|
|
* const { count } = await prisma.auditEvent.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends AuditEventDeleteManyArgs>(args?: SelectSubset<T, AuditEventDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more AuditEvents.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AuditEventUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many AuditEvents
|
|
* const auditEvent = await prisma.auditEvent.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends AuditEventUpdateManyArgs>(args: SelectSubset<T, AuditEventUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more AuditEvents and returns the data updated in the database.
|
|
* @param {AuditEventUpdateManyAndReturnArgs} args - Arguments to update many AuditEvents.
|
|
* @example
|
|
* // Update many AuditEvents
|
|
* const auditEvent = await prisma.auditEvent.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more AuditEvents and only return the `id`
|
|
* const auditEventWithIdOnly = await prisma.auditEvent.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends AuditEventUpdateManyAndReturnArgs>(args: SelectSubset<T, AuditEventUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one AuditEvent.
|
|
* @param {AuditEventUpsertArgs} args - Arguments to update or create a AuditEvent.
|
|
* @example
|
|
* // Update or create a AuditEvent
|
|
* const auditEvent = await prisma.auditEvent.upsert({
|
|
* create: {
|
|
* // ... data to create a AuditEvent
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the AuditEvent we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends AuditEventUpsertArgs>(args: SelectSubset<T, AuditEventUpsertArgs<ExtArgs>>): Prisma__AuditEventClient<$Result.GetResult<Prisma.$AuditEventPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of AuditEvents.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AuditEventCountArgs} args - Arguments to filter AuditEvents to count.
|
|
* @example
|
|
* // Count the number of AuditEvents
|
|
* const count = await prisma.auditEvent.count({
|
|
* where: {
|
|
* // ... the filter for the AuditEvents we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends AuditEventCountArgs>(
|
|
args?: Subset<T, AuditEventCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], AuditEventCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a AuditEvent.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AuditEventAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends AuditEventAggregateArgs>(args: Subset<T, AuditEventAggregateArgs>): Prisma.PrismaPromise<GetAuditEventAggregateType<T>>
|
|
|
|
/**
|
|
* Group by AuditEvent.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AuditEventGroupByArgs} 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 AuditEventGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: AuditEventGroupByArgs['orderBy'] }
|
|
: { orderBy?: AuditEventGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, AuditEventGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAuditEventGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the AuditEvent model
|
|
*/
|
|
readonly fields: AuditEventFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for AuditEvent.
|
|
* 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__AuditEventClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the AuditEvent model
|
|
*/
|
|
interface AuditEventFieldRefs {
|
|
readonly id: FieldRef<"AuditEvent", 'String'>
|
|
readonly actorType: FieldRef<"AuditEvent", 'String'>
|
|
readonly actorId: FieldRef<"AuditEvent", 'String'>
|
|
readonly action: FieldRef<"AuditEvent", 'String'>
|
|
readonly entityType: FieldRef<"AuditEvent", 'String'>
|
|
readonly entityId: FieldRef<"AuditEvent", 'String'>
|
|
readonly beforeState: FieldRef<"AuditEvent", 'Json'>
|
|
readonly afterState: FieldRef<"AuditEvent", 'Json'>
|
|
readonly reason: FieldRef<"AuditEvent", 'String'>
|
|
readonly metadata: FieldRef<"AuditEvent", 'Json'>
|
|
readonly createdAt: FieldRef<"AuditEvent", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* AuditEvent findUnique
|
|
*/
|
|
export type AuditEventFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which AuditEvent to fetch.
|
|
*/
|
|
where: AuditEventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AuditEvent findUniqueOrThrow
|
|
*/
|
|
export type AuditEventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which AuditEvent to fetch.
|
|
*/
|
|
where: AuditEventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AuditEvent findFirst
|
|
*/
|
|
export type AuditEventFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which AuditEvent to fetch.
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AuditEvents to fetch.
|
|
*/
|
|
orderBy?: AuditEventOrderByWithRelationInput | AuditEventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for AuditEvents.
|
|
*/
|
|
cursor?: AuditEventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AuditEvents from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` AuditEvents.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of AuditEvents.
|
|
*/
|
|
distinct?: AuditEventScalarFieldEnum | AuditEventScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* AuditEvent findFirstOrThrow
|
|
*/
|
|
export type AuditEventFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which AuditEvent to fetch.
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AuditEvents to fetch.
|
|
*/
|
|
orderBy?: AuditEventOrderByWithRelationInput | AuditEventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for AuditEvents.
|
|
*/
|
|
cursor?: AuditEventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AuditEvents from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` AuditEvents.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of AuditEvents.
|
|
*/
|
|
distinct?: AuditEventScalarFieldEnum | AuditEventScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* AuditEvent findMany
|
|
*/
|
|
export type AuditEventFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which AuditEvents to fetch.
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AuditEvents to fetch.
|
|
*/
|
|
orderBy?: AuditEventOrderByWithRelationInput | AuditEventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing AuditEvents.
|
|
*/
|
|
cursor?: AuditEventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AuditEvents from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` AuditEvents.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of AuditEvents.
|
|
*/
|
|
distinct?: AuditEventScalarFieldEnum | AuditEventScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* AuditEvent create
|
|
*/
|
|
export type AuditEventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a AuditEvent.
|
|
*/
|
|
data: XOR<AuditEventCreateInput, AuditEventUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* AuditEvent createMany
|
|
*/
|
|
export type AuditEventCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many AuditEvents.
|
|
*/
|
|
data: AuditEventCreateManyInput | AuditEventCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* AuditEvent createManyAndReturn
|
|
*/
|
|
export type AuditEventCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many AuditEvents.
|
|
*/
|
|
data: AuditEventCreateManyInput | AuditEventCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* AuditEvent update
|
|
*/
|
|
export type AuditEventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a AuditEvent.
|
|
*/
|
|
data: XOR<AuditEventUpdateInput, AuditEventUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which AuditEvent to update.
|
|
*/
|
|
where: AuditEventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AuditEvent updateMany
|
|
*/
|
|
export type AuditEventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update AuditEvents.
|
|
*/
|
|
data: XOR<AuditEventUpdateManyMutationInput, AuditEventUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which AuditEvents to update
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* Limit how many AuditEvents to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* AuditEvent updateManyAndReturn
|
|
*/
|
|
export type AuditEventUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update AuditEvents.
|
|
*/
|
|
data: XOR<AuditEventUpdateManyMutationInput, AuditEventUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which AuditEvents to update
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* Limit how many AuditEvents to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* AuditEvent upsert
|
|
*/
|
|
export type AuditEventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the AuditEvent to update in case it exists.
|
|
*/
|
|
where: AuditEventWhereUniqueInput
|
|
/**
|
|
* In case the AuditEvent found by the `where` argument doesn't exist, create a new AuditEvent with this data.
|
|
*/
|
|
create: XOR<AuditEventCreateInput, AuditEventUncheckedCreateInput>
|
|
/**
|
|
* In case the AuditEvent was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<AuditEventUpdateInput, AuditEventUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* AuditEvent delete
|
|
*/
|
|
export type AuditEventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter which AuditEvent to delete.
|
|
*/
|
|
where: AuditEventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AuditEvent deleteMany
|
|
*/
|
|
export type AuditEventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which AuditEvents to delete
|
|
*/
|
|
where?: AuditEventWhereInput
|
|
/**
|
|
* Limit how many AuditEvents to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* AuditEvent without action
|
|
*/
|
|
export type AuditEventDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AuditEvent
|
|
*/
|
|
select?: AuditEventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the AuditEvent
|
|
*/
|
|
omit?: AuditEventOmit<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model LedgerEntry
|
|
*/
|
|
|
|
export type AggregateLedgerEntry = {
|
|
_count: LedgerEntryCountAggregateOutputType | null
|
|
_avg: LedgerEntryAvgAggregateOutputType | null
|
|
_sum: LedgerEntrySumAggregateOutputType | null
|
|
_min: LedgerEntryMinAggregateOutputType | null
|
|
_max: LedgerEntryMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type LedgerEntryAvgAggregateOutputType = {
|
|
http_status: number | null
|
|
}
|
|
|
|
export type LedgerEntrySumAggregateOutputType = {
|
|
http_status: number | null
|
|
}
|
|
|
|
export type LedgerEntryMinAggregateOutputType = {
|
|
id: string | null
|
|
task_id: string | null
|
|
phase: string | null
|
|
idempotency_key: string | null
|
|
stripe_object_id: string | null
|
|
response_status: string | null
|
|
http_status: number | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type LedgerEntryMaxAggregateOutputType = {
|
|
id: string | null
|
|
task_id: string | null
|
|
phase: string | null
|
|
idempotency_key: string | null
|
|
stripe_object_id: string | null
|
|
response_status: string | null
|
|
http_status: number | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
}
|
|
|
|
export type LedgerEntryCountAggregateOutputType = {
|
|
id: number
|
|
task_id: number
|
|
phase: number
|
|
idempotency_key: number
|
|
stripe_object_id: number
|
|
response_status: number
|
|
http_status: number
|
|
created_at: number
|
|
updated_at: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type LedgerEntryAvgAggregateInputType = {
|
|
http_status?: true
|
|
}
|
|
|
|
export type LedgerEntrySumAggregateInputType = {
|
|
http_status?: true
|
|
}
|
|
|
|
export type LedgerEntryMinAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
phase?: true
|
|
idempotency_key?: true
|
|
stripe_object_id?: true
|
|
response_status?: true
|
|
http_status?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type LedgerEntryMaxAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
phase?: true
|
|
idempotency_key?: true
|
|
stripe_object_id?: true
|
|
response_status?: true
|
|
http_status?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
}
|
|
|
|
export type LedgerEntryCountAggregateInputType = {
|
|
id?: true
|
|
task_id?: true
|
|
phase?: true
|
|
idempotency_key?: true
|
|
stripe_object_id?: true
|
|
response_status?: true
|
|
http_status?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type LedgerEntryAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which LedgerEntry to aggregate.
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LedgerEntries to fetch.
|
|
*/
|
|
orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: LedgerEntryWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LedgerEntries from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LedgerEntries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned LedgerEntries
|
|
**/
|
|
_count?: true | LedgerEntryCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: LedgerEntryAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: LedgerEntrySumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: LedgerEntryMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: LedgerEntryMaxAggregateInputType
|
|
}
|
|
|
|
export type GetLedgerEntryAggregateType<T extends LedgerEntryAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateLedgerEntry]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateLedgerEntry[P]>
|
|
: GetScalarType<T[P], AggregateLedgerEntry[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type LedgerEntryGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: LedgerEntryWhereInput
|
|
orderBy?: LedgerEntryOrderByWithAggregationInput | LedgerEntryOrderByWithAggregationInput[]
|
|
by: LedgerEntryScalarFieldEnum[] | LedgerEntryScalarFieldEnum
|
|
having?: LedgerEntryScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: LedgerEntryCountAggregateInputType | true
|
|
_avg?: LedgerEntryAvgAggregateInputType
|
|
_sum?: LedgerEntrySumAggregateInputType
|
|
_min?: LedgerEntryMinAggregateInputType
|
|
_max?: LedgerEntryMaxAggregateInputType
|
|
}
|
|
|
|
export type LedgerEntryGroupByOutputType = {
|
|
id: string
|
|
task_id: string
|
|
phase: string
|
|
idempotency_key: string
|
|
stripe_object_id: string | null
|
|
response_status: string
|
|
http_status: number
|
|
created_at: Date
|
|
updated_at: Date
|
|
_count: LedgerEntryCountAggregateOutputType | null
|
|
_avg: LedgerEntryAvgAggregateOutputType | null
|
|
_sum: LedgerEntrySumAggregateOutputType | null
|
|
_min: LedgerEntryMinAggregateOutputType | null
|
|
_max: LedgerEntryMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetLedgerEntryGroupByPayload<T extends LedgerEntryGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<LedgerEntryGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof LedgerEntryGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], LedgerEntryGroupByOutputType[P]>
|
|
: GetScalarType<T[P], LedgerEntryGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type LedgerEntrySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
phase?: boolean
|
|
idempotency_key?: boolean
|
|
stripe_object_id?: boolean
|
|
response_status?: boolean
|
|
http_status?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}, ExtArgs["result"]["ledgerEntry"]>
|
|
|
|
export type LedgerEntrySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
phase?: boolean
|
|
idempotency_key?: boolean
|
|
stripe_object_id?: boolean
|
|
response_status?: boolean
|
|
http_status?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}, ExtArgs["result"]["ledgerEntry"]>
|
|
|
|
export type LedgerEntrySelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
task_id?: boolean
|
|
phase?: boolean
|
|
idempotency_key?: boolean
|
|
stripe_object_id?: boolean
|
|
response_status?: boolean
|
|
http_status?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}, ExtArgs["result"]["ledgerEntry"]>
|
|
|
|
export type LedgerEntrySelectScalar = {
|
|
id?: boolean
|
|
task_id?: boolean
|
|
phase?: boolean
|
|
idempotency_key?: boolean
|
|
stripe_object_id?: boolean
|
|
response_status?: boolean
|
|
http_status?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
}
|
|
|
|
export type LedgerEntryOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "task_id" | "phase" | "idempotency_key" | "stripe_object_id" | "response_status" | "http_status" | "created_at" | "updated_at", ExtArgs["result"]["ledgerEntry"]>
|
|
|
|
export type $LedgerEntryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "LedgerEntry"
|
|
objects: {}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
task_id: string
|
|
phase: string
|
|
idempotency_key: string
|
|
stripe_object_id: string | null
|
|
response_status: string
|
|
http_status: number
|
|
created_at: Date
|
|
updated_at: Date
|
|
}, ExtArgs["result"]["ledgerEntry"]>
|
|
composites: {}
|
|
}
|
|
|
|
type LedgerEntryGetPayload<S extends boolean | null | undefined | LedgerEntryDefaultArgs> = $Result.GetResult<Prisma.$LedgerEntryPayload, S>
|
|
|
|
type LedgerEntryCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<LedgerEntryFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: LedgerEntryCountAggregateInputType | true
|
|
}
|
|
|
|
export interface LedgerEntryDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['LedgerEntry'], meta: { name: 'LedgerEntry' } }
|
|
/**
|
|
* Find zero or one LedgerEntry that matches the filter.
|
|
* @param {LedgerEntryFindUniqueArgs} args - Arguments to find a LedgerEntry
|
|
* @example
|
|
* // Get one LedgerEntry
|
|
* const ledgerEntry = await prisma.ledgerEntry.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends LedgerEntryFindUniqueArgs>(args: SelectSubset<T, LedgerEntryFindUniqueArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one LedgerEntry that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {LedgerEntryFindUniqueOrThrowArgs} args - Arguments to find a LedgerEntry
|
|
* @example
|
|
* // Get one LedgerEntry
|
|
* const ledgerEntry = await prisma.ledgerEntry.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends LedgerEntryFindUniqueOrThrowArgs>(args: SelectSubset<T, LedgerEntryFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first LedgerEntry 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 {LedgerEntryFindFirstArgs} args - Arguments to find a LedgerEntry
|
|
* @example
|
|
* // Get one LedgerEntry
|
|
* const ledgerEntry = await prisma.ledgerEntry.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends LedgerEntryFindFirstArgs>(args?: SelectSubset<T, LedgerEntryFindFirstArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first LedgerEntry 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 {LedgerEntryFindFirstOrThrowArgs} args - Arguments to find a LedgerEntry
|
|
* @example
|
|
* // Get one LedgerEntry
|
|
* const ledgerEntry = await prisma.ledgerEntry.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends LedgerEntryFindFirstOrThrowArgs>(args?: SelectSubset<T, LedgerEntryFindFirstOrThrowArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more LedgerEntries 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 {LedgerEntryFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all LedgerEntries
|
|
* const ledgerEntries = await prisma.ledgerEntry.findMany()
|
|
*
|
|
* // Get first 10 LedgerEntries
|
|
* const ledgerEntries = await prisma.ledgerEntry.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const ledgerEntryWithIdOnly = await prisma.ledgerEntry.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends LedgerEntryFindManyArgs>(args?: SelectSubset<T, LedgerEntryFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a LedgerEntry.
|
|
* @param {LedgerEntryCreateArgs} args - Arguments to create a LedgerEntry.
|
|
* @example
|
|
* // Create one LedgerEntry
|
|
* const LedgerEntry = await prisma.ledgerEntry.create({
|
|
* data: {
|
|
* // ... data to create a LedgerEntry
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends LedgerEntryCreateArgs>(args: SelectSubset<T, LedgerEntryCreateArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many LedgerEntries.
|
|
* @param {LedgerEntryCreateManyArgs} args - Arguments to create many LedgerEntries.
|
|
* @example
|
|
* // Create many LedgerEntries
|
|
* const ledgerEntry = await prisma.ledgerEntry.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends LedgerEntryCreateManyArgs>(args?: SelectSubset<T, LedgerEntryCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many LedgerEntries and returns the data saved in the database.
|
|
* @param {LedgerEntryCreateManyAndReturnArgs} args - Arguments to create many LedgerEntries.
|
|
* @example
|
|
* // Create many LedgerEntries
|
|
* const ledgerEntry = await prisma.ledgerEntry.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many LedgerEntries and only return the `id`
|
|
* const ledgerEntryWithIdOnly = await prisma.ledgerEntry.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends LedgerEntryCreateManyAndReturnArgs>(args?: SelectSubset<T, LedgerEntryCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a LedgerEntry.
|
|
* @param {LedgerEntryDeleteArgs} args - Arguments to delete one LedgerEntry.
|
|
* @example
|
|
* // Delete one LedgerEntry
|
|
* const LedgerEntry = await prisma.ledgerEntry.delete({
|
|
* where: {
|
|
* // ... filter to delete one LedgerEntry
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends LedgerEntryDeleteArgs>(args: SelectSubset<T, LedgerEntryDeleteArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one LedgerEntry.
|
|
* @param {LedgerEntryUpdateArgs} args - Arguments to update one LedgerEntry.
|
|
* @example
|
|
* // Update one LedgerEntry
|
|
* const ledgerEntry = await prisma.ledgerEntry.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends LedgerEntryUpdateArgs>(args: SelectSubset<T, LedgerEntryUpdateArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more LedgerEntries.
|
|
* @param {LedgerEntryDeleteManyArgs} args - Arguments to filter LedgerEntries to delete.
|
|
* @example
|
|
* // Delete a few LedgerEntries
|
|
* const { count } = await prisma.ledgerEntry.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends LedgerEntryDeleteManyArgs>(args?: SelectSubset<T, LedgerEntryDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more LedgerEntries.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LedgerEntryUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many LedgerEntries
|
|
* const ledgerEntry = await prisma.ledgerEntry.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends LedgerEntryUpdateManyArgs>(args: SelectSubset<T, LedgerEntryUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more LedgerEntries and returns the data updated in the database.
|
|
* @param {LedgerEntryUpdateManyAndReturnArgs} args - Arguments to update many LedgerEntries.
|
|
* @example
|
|
* // Update many LedgerEntries
|
|
* const ledgerEntry = await prisma.ledgerEntry.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more LedgerEntries and only return the `id`
|
|
* const ledgerEntryWithIdOnly = await prisma.ledgerEntry.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends LedgerEntryUpdateManyAndReturnArgs>(args: SelectSubset<T, LedgerEntryUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one LedgerEntry.
|
|
* @param {LedgerEntryUpsertArgs} args - Arguments to update or create a LedgerEntry.
|
|
* @example
|
|
* // Update or create a LedgerEntry
|
|
* const ledgerEntry = await prisma.ledgerEntry.upsert({
|
|
* create: {
|
|
* // ... data to create a LedgerEntry
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the LedgerEntry we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends LedgerEntryUpsertArgs>(args: SelectSubset<T, LedgerEntryUpsertArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of LedgerEntries.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LedgerEntryCountArgs} args - Arguments to filter LedgerEntries to count.
|
|
* @example
|
|
* // Count the number of LedgerEntries
|
|
* const count = await prisma.ledgerEntry.count({
|
|
* where: {
|
|
* // ... the filter for the LedgerEntries we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends LedgerEntryCountArgs>(
|
|
args?: Subset<T, LedgerEntryCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], LedgerEntryCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a LedgerEntry.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LedgerEntryAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends LedgerEntryAggregateArgs>(args: Subset<T, LedgerEntryAggregateArgs>): Prisma.PrismaPromise<GetLedgerEntryAggregateType<T>>
|
|
|
|
/**
|
|
* Group by LedgerEntry.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LedgerEntryGroupByArgs} 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 LedgerEntryGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: LedgerEntryGroupByArgs['orderBy'] }
|
|
: { orderBy?: LedgerEntryGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, LedgerEntryGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLedgerEntryGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the LedgerEntry model
|
|
*/
|
|
readonly fields: LedgerEntryFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for LedgerEntry.
|
|
* 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__LedgerEntryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the LedgerEntry model
|
|
*/
|
|
interface LedgerEntryFieldRefs {
|
|
readonly id: FieldRef<"LedgerEntry", 'String'>
|
|
readonly task_id: FieldRef<"LedgerEntry", 'String'>
|
|
readonly phase: FieldRef<"LedgerEntry", 'String'>
|
|
readonly idempotency_key: FieldRef<"LedgerEntry", 'String'>
|
|
readonly stripe_object_id: FieldRef<"LedgerEntry", 'String'>
|
|
readonly response_status: FieldRef<"LedgerEntry", 'String'>
|
|
readonly http_status: FieldRef<"LedgerEntry", 'Int'>
|
|
readonly created_at: FieldRef<"LedgerEntry", 'DateTime'>
|
|
readonly updated_at: FieldRef<"LedgerEntry", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* LedgerEntry findUnique
|
|
*/
|
|
export type LedgerEntryFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which LedgerEntry to fetch.
|
|
*/
|
|
where: LedgerEntryWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry findUniqueOrThrow
|
|
*/
|
|
export type LedgerEntryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which LedgerEntry to fetch.
|
|
*/
|
|
where: LedgerEntryWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry findFirst
|
|
*/
|
|
export type LedgerEntryFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which LedgerEntry to fetch.
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LedgerEntries to fetch.
|
|
*/
|
|
orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for LedgerEntries.
|
|
*/
|
|
cursor?: LedgerEntryWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LedgerEntries from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LedgerEntries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of LedgerEntries.
|
|
*/
|
|
distinct?: LedgerEntryScalarFieldEnum | LedgerEntryScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry findFirstOrThrow
|
|
*/
|
|
export type LedgerEntryFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which LedgerEntry to fetch.
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LedgerEntries to fetch.
|
|
*/
|
|
orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for LedgerEntries.
|
|
*/
|
|
cursor?: LedgerEntryWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LedgerEntries from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LedgerEntries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of LedgerEntries.
|
|
*/
|
|
distinct?: LedgerEntryScalarFieldEnum | LedgerEntryScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry findMany
|
|
*/
|
|
export type LedgerEntryFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which LedgerEntries to fetch.
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LedgerEntries to fetch.
|
|
*/
|
|
orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing LedgerEntries.
|
|
*/
|
|
cursor?: LedgerEntryWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LedgerEntries from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LedgerEntries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of LedgerEntries.
|
|
*/
|
|
distinct?: LedgerEntryScalarFieldEnum | LedgerEntryScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry create
|
|
*/
|
|
export type LedgerEntryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a LedgerEntry.
|
|
*/
|
|
data: XOR<LedgerEntryCreateInput, LedgerEntryUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry createMany
|
|
*/
|
|
export type LedgerEntryCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many LedgerEntries.
|
|
*/
|
|
data: LedgerEntryCreateManyInput | LedgerEntryCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry createManyAndReturn
|
|
*/
|
|
export type LedgerEntryCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many LedgerEntries.
|
|
*/
|
|
data: LedgerEntryCreateManyInput | LedgerEntryCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry update
|
|
*/
|
|
export type LedgerEntryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a LedgerEntry.
|
|
*/
|
|
data: XOR<LedgerEntryUpdateInput, LedgerEntryUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which LedgerEntry to update.
|
|
*/
|
|
where: LedgerEntryWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry updateMany
|
|
*/
|
|
export type LedgerEntryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update LedgerEntries.
|
|
*/
|
|
data: XOR<LedgerEntryUpdateManyMutationInput, LedgerEntryUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which LedgerEntries to update
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* Limit how many LedgerEntries to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry updateManyAndReturn
|
|
*/
|
|
export type LedgerEntryUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update LedgerEntries.
|
|
*/
|
|
data: XOR<LedgerEntryUpdateManyMutationInput, LedgerEntryUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which LedgerEntries to update
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* Limit how many LedgerEntries to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry upsert
|
|
*/
|
|
export type LedgerEntryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the LedgerEntry to update in case it exists.
|
|
*/
|
|
where: LedgerEntryWhereUniqueInput
|
|
/**
|
|
* In case the LedgerEntry found by the `where` argument doesn't exist, create a new LedgerEntry with this data.
|
|
*/
|
|
create: XOR<LedgerEntryCreateInput, LedgerEntryUncheckedCreateInput>
|
|
/**
|
|
* In case the LedgerEntry was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<LedgerEntryUpdateInput, LedgerEntryUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry delete
|
|
*/
|
|
export type LedgerEntryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
/**
|
|
* Filter which LedgerEntry to delete.
|
|
*/
|
|
where: LedgerEntryWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry deleteMany
|
|
*/
|
|
export type LedgerEntryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which LedgerEntries to delete
|
|
*/
|
|
where?: LedgerEntryWhereInput
|
|
/**
|
|
* Limit how many LedgerEntries to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* LedgerEntry without action
|
|
*/
|
|
export type LedgerEntryDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LedgerEntry
|
|
*/
|
|
select?: LedgerEntrySelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LedgerEntry
|
|
*/
|
|
omit?: LedgerEntryOmit<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Enums
|
|
*/
|
|
|
|
export const TransactionIsolationLevel: {
|
|
ReadUncommitted: 'ReadUncommitted',
|
|
ReadCommitted: 'ReadCommitted',
|
|
RepeatableRead: 'RepeatableRead',
|
|
Serializable: 'Serializable'
|
|
};
|
|
|
|
export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
|
|
|
|
|
|
export const TaskScalarFieldEnum: {
|
|
id: 'id',
|
|
title: 'title',
|
|
description: 'description',
|
|
status: 'status',
|
|
difficulty: 'difficulty',
|
|
scope_clarity_score: 'scope_clarity_score',
|
|
error_classification: 'error_classification',
|
|
reward_amount: 'reward_amount',
|
|
reward_currency: 'reward_currency',
|
|
acceptance_criteria: 'acceptance_criteria',
|
|
required_stack: 'required_stack',
|
|
retry_count: 'retry_count',
|
|
stripe_payment_intent_id: 'stripe_payment_intent_id',
|
|
expires_at: 'expires_at',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at'
|
|
};
|
|
|
|
export type TaskScalarFieldEnum = (typeof TaskScalarFieldEnum)[keyof typeof TaskScalarFieldEnum]
|
|
|
|
|
|
export const ClaimScalarFieldEnum: {
|
|
id: 'id',
|
|
task_id: 'task_id',
|
|
developer_wallet: 'developer_wallet',
|
|
status: 'status',
|
|
claim_token: 'claim_token',
|
|
held_amount: 'held_amount',
|
|
held_currency: 'held_currency',
|
|
expires_at: 'expires_at',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at'
|
|
};
|
|
|
|
export type ClaimScalarFieldEnum = (typeof ClaimScalarFieldEnum)[keyof typeof ClaimScalarFieldEnum]
|
|
|
|
|
|
export const SubmissionScalarFieldEnum: {
|
|
id: 'id',
|
|
task_id: 'task_id',
|
|
claim_id: 'claim_id',
|
|
status: 'status',
|
|
deliverables: 'deliverables',
|
|
estimated_judge_complete_at: 'estimated_judge_complete_at',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at'
|
|
};
|
|
|
|
export type SubmissionScalarFieldEnum = (typeof SubmissionScalarFieldEnum)[keyof typeof SubmissionScalarFieldEnum]
|
|
|
|
|
|
export const JudgeResultScalarFieldEnum: {
|
|
id: 'id',
|
|
submission_id: 'submission_id',
|
|
overall_result: 'overall_result',
|
|
tests: 'tests',
|
|
artifacts: 'artifacts',
|
|
error_classification: 'error_classification',
|
|
error_signature: 'error_signature',
|
|
retryable: 'retryable',
|
|
resource_usage: 'resource_usage',
|
|
judge_completed_at: 'judge_completed_at'
|
|
};
|
|
|
|
export type JudgeResultScalarFieldEnum = (typeof JudgeResultScalarFieldEnum)[keyof typeof JudgeResultScalarFieldEnum]
|
|
|
|
|
|
export const AuditEventScalarFieldEnum: {
|
|
id: 'id',
|
|
actorType: 'actorType',
|
|
actorId: 'actorId',
|
|
action: 'action',
|
|
entityType: 'entityType',
|
|
entityId: 'entityId',
|
|
beforeState: 'beforeState',
|
|
afterState: 'afterState',
|
|
reason: 'reason',
|
|
metadata: 'metadata',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type AuditEventScalarFieldEnum = (typeof AuditEventScalarFieldEnum)[keyof typeof AuditEventScalarFieldEnum]
|
|
|
|
|
|
export const LedgerEntryScalarFieldEnum: {
|
|
id: 'id',
|
|
task_id: 'task_id',
|
|
phase: 'phase',
|
|
idempotency_key: 'idempotency_key',
|
|
stripe_object_id: 'stripe_object_id',
|
|
response_status: 'response_status',
|
|
http_status: 'http_status',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at'
|
|
};
|
|
|
|
export type LedgerEntryScalarFieldEnum = (typeof LedgerEntryScalarFieldEnum)[keyof typeof LedgerEntryScalarFieldEnum]
|
|
|
|
|
|
export const SortOrder: {
|
|
asc: 'asc',
|
|
desc: 'desc'
|
|
};
|
|
|
|
export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
|
|
|
|
|
|
export const JsonNullValueInput: {
|
|
JsonNull: typeof JsonNull
|
|
};
|
|
|
|
export type JsonNullValueInput = (typeof JsonNullValueInput)[keyof typeof JsonNullValueInput]
|
|
|
|
|
|
export const NullableJsonNullValueInput: {
|
|
DbNull: typeof DbNull,
|
|
JsonNull: typeof JsonNull
|
|
};
|
|
|
|
export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]
|
|
|
|
|
|
export const QueryMode: {
|
|
default: 'default',
|
|
insensitive: 'insensitive'
|
|
};
|
|
|
|
export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
|
|
|
|
|
|
export const JsonNullValueFilter: {
|
|
DbNull: typeof DbNull,
|
|
JsonNull: typeof JsonNull,
|
|
AnyNull: typeof AnyNull
|
|
};
|
|
|
|
export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]
|
|
|
|
|
|
export const NullsOrder: {
|
|
first: 'first',
|
|
last: 'last'
|
|
};
|
|
|
|
export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
|
|
|
|
|
|
/**
|
|
* Field references
|
|
*/
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'String'
|
|
*/
|
|
export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'String[]'
|
|
*/
|
|
export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Float'
|
|
*/
|
|
export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Float[]'
|
|
*/
|
|
export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Int'
|
|
*/
|
|
export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Int[]'
|
|
*/
|
|
export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Json'
|
|
*/
|
|
export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'QueryMode'
|
|
*/
|
|
export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'DateTime'
|
|
*/
|
|
export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'DateTime[]'
|
|
*/
|
|
export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Boolean'
|
|
*/
|
|
export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
|
|
|
|
/**
|
|
* Deep Input Types
|
|
*/
|
|
|
|
|
|
export type TaskWhereInput = {
|
|
AND?: TaskWhereInput | TaskWhereInput[]
|
|
OR?: TaskWhereInput[]
|
|
NOT?: TaskWhereInput | TaskWhereInput[]
|
|
id?: StringFilter<"Task"> | string
|
|
title?: StringFilter<"Task"> | string
|
|
description?: StringFilter<"Task"> | string
|
|
status?: StringFilter<"Task"> | string
|
|
difficulty?: StringFilter<"Task"> | string
|
|
scope_clarity_score?: FloatFilter<"Task"> | number
|
|
error_classification?: StringNullableFilter<"Task"> | string | null
|
|
reward_amount?: IntFilter<"Task"> | number
|
|
reward_currency?: StringFilter<"Task"> | string
|
|
acceptance_criteria?: JsonFilter<"Task">
|
|
required_stack?: StringNullableListFilter<"Task">
|
|
retry_count?: IntFilter<"Task"> | number
|
|
stripe_payment_intent_id?: StringNullableFilter<"Task"> | string | null
|
|
expires_at?: DateTimeNullableFilter<"Task"> | Date | string | null
|
|
created_at?: DateTimeFilter<"Task"> | Date | string
|
|
updated_at?: DateTimeFilter<"Task"> | Date | string
|
|
claims?: ClaimListRelationFilter
|
|
submissions?: SubmissionListRelationFilter
|
|
}
|
|
|
|
export type TaskOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
status?: SortOrder
|
|
difficulty?: SortOrder
|
|
scope_clarity_score?: SortOrder
|
|
error_classification?: SortOrderInput | SortOrder
|
|
reward_amount?: SortOrder
|
|
reward_currency?: SortOrder
|
|
acceptance_criteria?: SortOrder
|
|
required_stack?: SortOrder
|
|
retry_count?: SortOrder
|
|
stripe_payment_intent_id?: SortOrderInput | SortOrder
|
|
expires_at?: SortOrderInput | SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
claims?: ClaimOrderByRelationAggregateInput
|
|
submissions?: SubmissionOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type TaskWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: TaskWhereInput | TaskWhereInput[]
|
|
OR?: TaskWhereInput[]
|
|
NOT?: TaskWhereInput | TaskWhereInput[]
|
|
title?: StringFilter<"Task"> | string
|
|
description?: StringFilter<"Task"> | string
|
|
status?: StringFilter<"Task"> | string
|
|
difficulty?: StringFilter<"Task"> | string
|
|
scope_clarity_score?: FloatFilter<"Task"> | number
|
|
error_classification?: StringNullableFilter<"Task"> | string | null
|
|
reward_amount?: IntFilter<"Task"> | number
|
|
reward_currency?: StringFilter<"Task"> | string
|
|
acceptance_criteria?: JsonFilter<"Task">
|
|
required_stack?: StringNullableListFilter<"Task">
|
|
retry_count?: IntFilter<"Task"> | number
|
|
stripe_payment_intent_id?: StringNullableFilter<"Task"> | string | null
|
|
expires_at?: DateTimeNullableFilter<"Task"> | Date | string | null
|
|
created_at?: DateTimeFilter<"Task"> | Date | string
|
|
updated_at?: DateTimeFilter<"Task"> | Date | string
|
|
claims?: ClaimListRelationFilter
|
|
submissions?: SubmissionListRelationFilter
|
|
}, "id">
|
|
|
|
export type TaskOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
status?: SortOrder
|
|
difficulty?: SortOrder
|
|
scope_clarity_score?: SortOrder
|
|
error_classification?: SortOrderInput | SortOrder
|
|
reward_amount?: SortOrder
|
|
reward_currency?: SortOrder
|
|
acceptance_criteria?: SortOrder
|
|
required_stack?: SortOrder
|
|
retry_count?: SortOrder
|
|
stripe_payment_intent_id?: SortOrderInput | SortOrder
|
|
expires_at?: SortOrderInput | SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
_count?: TaskCountOrderByAggregateInput
|
|
_avg?: TaskAvgOrderByAggregateInput
|
|
_max?: TaskMaxOrderByAggregateInput
|
|
_min?: TaskMinOrderByAggregateInput
|
|
_sum?: TaskSumOrderByAggregateInput
|
|
}
|
|
|
|
export type TaskScalarWhereWithAggregatesInput = {
|
|
AND?: TaskScalarWhereWithAggregatesInput | TaskScalarWhereWithAggregatesInput[]
|
|
OR?: TaskScalarWhereWithAggregatesInput[]
|
|
NOT?: TaskScalarWhereWithAggregatesInput | TaskScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Task"> | string
|
|
title?: StringWithAggregatesFilter<"Task"> | string
|
|
description?: StringWithAggregatesFilter<"Task"> | string
|
|
status?: StringWithAggregatesFilter<"Task"> | string
|
|
difficulty?: StringWithAggregatesFilter<"Task"> | string
|
|
scope_clarity_score?: FloatWithAggregatesFilter<"Task"> | number
|
|
error_classification?: StringNullableWithAggregatesFilter<"Task"> | string | null
|
|
reward_amount?: IntWithAggregatesFilter<"Task"> | number
|
|
reward_currency?: StringWithAggregatesFilter<"Task"> | string
|
|
acceptance_criteria?: JsonWithAggregatesFilter<"Task">
|
|
required_stack?: StringNullableListFilter<"Task">
|
|
retry_count?: IntWithAggregatesFilter<"Task"> | number
|
|
stripe_payment_intent_id?: StringNullableWithAggregatesFilter<"Task"> | string | null
|
|
expires_at?: DateTimeNullableWithAggregatesFilter<"Task"> | Date | string | null
|
|
created_at?: DateTimeWithAggregatesFilter<"Task"> | Date | string
|
|
updated_at?: DateTimeWithAggregatesFilter<"Task"> | Date | string
|
|
}
|
|
|
|
export type ClaimWhereInput = {
|
|
AND?: ClaimWhereInput | ClaimWhereInput[]
|
|
OR?: ClaimWhereInput[]
|
|
NOT?: ClaimWhereInput | ClaimWhereInput[]
|
|
id?: StringFilter<"Claim"> | string
|
|
task_id?: StringFilter<"Claim"> | string
|
|
developer_wallet?: StringFilter<"Claim"> | string
|
|
status?: StringFilter<"Claim"> | string
|
|
claim_token?: StringFilter<"Claim"> | string
|
|
held_amount?: IntFilter<"Claim"> | number
|
|
held_currency?: StringFilter<"Claim"> | string
|
|
expires_at?: DateTimeFilter<"Claim"> | Date | string
|
|
created_at?: DateTimeFilter<"Claim"> | Date | string
|
|
updated_at?: DateTimeFilter<"Claim"> | Date | string
|
|
task?: XOR<TaskScalarRelationFilter, TaskWhereInput>
|
|
submissions?: SubmissionListRelationFilter
|
|
}
|
|
|
|
export type ClaimOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
developer_wallet?: SortOrder
|
|
status?: SortOrder
|
|
claim_token?: SortOrder
|
|
held_amount?: SortOrder
|
|
held_currency?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
task?: TaskOrderByWithRelationInput
|
|
submissions?: SubmissionOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type ClaimWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
claim_token?: string
|
|
AND?: ClaimWhereInput | ClaimWhereInput[]
|
|
OR?: ClaimWhereInput[]
|
|
NOT?: ClaimWhereInput | ClaimWhereInput[]
|
|
task_id?: StringFilter<"Claim"> | string
|
|
developer_wallet?: StringFilter<"Claim"> | string
|
|
status?: StringFilter<"Claim"> | string
|
|
held_amount?: IntFilter<"Claim"> | number
|
|
held_currency?: StringFilter<"Claim"> | string
|
|
expires_at?: DateTimeFilter<"Claim"> | Date | string
|
|
created_at?: DateTimeFilter<"Claim"> | Date | string
|
|
updated_at?: DateTimeFilter<"Claim"> | Date | string
|
|
task?: XOR<TaskScalarRelationFilter, TaskWhereInput>
|
|
submissions?: SubmissionListRelationFilter
|
|
}, "id" | "claim_token">
|
|
|
|
export type ClaimOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
developer_wallet?: SortOrder
|
|
status?: SortOrder
|
|
claim_token?: SortOrder
|
|
held_amount?: SortOrder
|
|
held_currency?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
_count?: ClaimCountOrderByAggregateInput
|
|
_avg?: ClaimAvgOrderByAggregateInput
|
|
_max?: ClaimMaxOrderByAggregateInput
|
|
_min?: ClaimMinOrderByAggregateInput
|
|
_sum?: ClaimSumOrderByAggregateInput
|
|
}
|
|
|
|
export type ClaimScalarWhereWithAggregatesInput = {
|
|
AND?: ClaimScalarWhereWithAggregatesInput | ClaimScalarWhereWithAggregatesInput[]
|
|
OR?: ClaimScalarWhereWithAggregatesInput[]
|
|
NOT?: ClaimScalarWhereWithAggregatesInput | ClaimScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Claim"> | string
|
|
task_id?: StringWithAggregatesFilter<"Claim"> | string
|
|
developer_wallet?: StringWithAggregatesFilter<"Claim"> | string
|
|
status?: StringWithAggregatesFilter<"Claim"> | string
|
|
claim_token?: StringWithAggregatesFilter<"Claim"> | string
|
|
held_amount?: IntWithAggregatesFilter<"Claim"> | number
|
|
held_currency?: StringWithAggregatesFilter<"Claim"> | string
|
|
expires_at?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
|
|
created_at?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
|
|
updated_at?: DateTimeWithAggregatesFilter<"Claim"> | Date | string
|
|
}
|
|
|
|
export type SubmissionWhereInput = {
|
|
AND?: SubmissionWhereInput | SubmissionWhereInput[]
|
|
OR?: SubmissionWhereInput[]
|
|
NOT?: SubmissionWhereInput | SubmissionWhereInput[]
|
|
id?: StringFilter<"Submission"> | string
|
|
task_id?: StringFilter<"Submission"> | string
|
|
claim_id?: StringFilter<"Submission"> | string
|
|
status?: StringFilter<"Submission"> | string
|
|
deliverables?: JsonFilter<"Submission">
|
|
estimated_judge_complete_at?: DateTimeNullableFilter<"Submission"> | Date | string | null
|
|
created_at?: DateTimeFilter<"Submission"> | Date | string
|
|
updated_at?: DateTimeFilter<"Submission"> | Date | string
|
|
task?: XOR<TaskScalarRelationFilter, TaskWhereInput>
|
|
claim?: XOR<ClaimScalarRelationFilter, ClaimWhereInput>
|
|
judge_results?: JudgeResultListRelationFilter
|
|
}
|
|
|
|
export type SubmissionOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
claim_id?: SortOrder
|
|
status?: SortOrder
|
|
deliverables?: SortOrder
|
|
estimated_judge_complete_at?: SortOrderInput | SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
task?: TaskOrderByWithRelationInput
|
|
claim?: ClaimOrderByWithRelationInput
|
|
judge_results?: JudgeResultOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type SubmissionWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: SubmissionWhereInput | SubmissionWhereInput[]
|
|
OR?: SubmissionWhereInput[]
|
|
NOT?: SubmissionWhereInput | SubmissionWhereInput[]
|
|
task_id?: StringFilter<"Submission"> | string
|
|
claim_id?: StringFilter<"Submission"> | string
|
|
status?: StringFilter<"Submission"> | string
|
|
deliverables?: JsonFilter<"Submission">
|
|
estimated_judge_complete_at?: DateTimeNullableFilter<"Submission"> | Date | string | null
|
|
created_at?: DateTimeFilter<"Submission"> | Date | string
|
|
updated_at?: DateTimeFilter<"Submission"> | Date | string
|
|
task?: XOR<TaskScalarRelationFilter, TaskWhereInput>
|
|
claim?: XOR<ClaimScalarRelationFilter, ClaimWhereInput>
|
|
judge_results?: JudgeResultListRelationFilter
|
|
}, "id">
|
|
|
|
export type SubmissionOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
claim_id?: SortOrder
|
|
status?: SortOrder
|
|
deliverables?: SortOrder
|
|
estimated_judge_complete_at?: SortOrderInput | SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
_count?: SubmissionCountOrderByAggregateInput
|
|
_max?: SubmissionMaxOrderByAggregateInput
|
|
_min?: SubmissionMinOrderByAggregateInput
|
|
}
|
|
|
|
export type SubmissionScalarWhereWithAggregatesInput = {
|
|
AND?: SubmissionScalarWhereWithAggregatesInput | SubmissionScalarWhereWithAggregatesInput[]
|
|
OR?: SubmissionScalarWhereWithAggregatesInput[]
|
|
NOT?: SubmissionScalarWhereWithAggregatesInput | SubmissionScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Submission"> | string
|
|
task_id?: StringWithAggregatesFilter<"Submission"> | string
|
|
claim_id?: StringWithAggregatesFilter<"Submission"> | string
|
|
status?: StringWithAggregatesFilter<"Submission"> | string
|
|
deliverables?: JsonWithAggregatesFilter<"Submission">
|
|
estimated_judge_complete_at?: DateTimeNullableWithAggregatesFilter<"Submission"> | Date | string | null
|
|
created_at?: DateTimeWithAggregatesFilter<"Submission"> | Date | string
|
|
updated_at?: DateTimeWithAggregatesFilter<"Submission"> | Date | string
|
|
}
|
|
|
|
export type JudgeResultWhereInput = {
|
|
AND?: JudgeResultWhereInput | JudgeResultWhereInput[]
|
|
OR?: JudgeResultWhereInput[]
|
|
NOT?: JudgeResultWhereInput | JudgeResultWhereInput[]
|
|
id?: StringFilter<"JudgeResult"> | string
|
|
submission_id?: StringFilter<"JudgeResult"> | string
|
|
overall_result?: StringFilter<"JudgeResult"> | string
|
|
tests?: JsonFilter<"JudgeResult">
|
|
artifacts?: JsonNullableFilter<"JudgeResult">
|
|
error_classification?: StringNullableFilter<"JudgeResult"> | string | null
|
|
error_signature?: StringNullableFilter<"JudgeResult"> | string | null
|
|
retryable?: BoolFilter<"JudgeResult"> | boolean
|
|
resource_usage?: JsonFilter<"JudgeResult">
|
|
judge_completed_at?: DateTimeFilter<"JudgeResult"> | Date | string
|
|
submission?: XOR<SubmissionScalarRelationFilter, SubmissionWhereInput>
|
|
}
|
|
|
|
export type JudgeResultOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
submission_id?: SortOrder
|
|
overall_result?: SortOrder
|
|
tests?: SortOrder
|
|
artifacts?: SortOrderInput | SortOrder
|
|
error_classification?: SortOrderInput | SortOrder
|
|
error_signature?: SortOrderInput | SortOrder
|
|
retryable?: SortOrder
|
|
resource_usage?: SortOrder
|
|
judge_completed_at?: SortOrder
|
|
submission?: SubmissionOrderByWithRelationInput
|
|
}
|
|
|
|
export type JudgeResultWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: JudgeResultWhereInput | JudgeResultWhereInput[]
|
|
OR?: JudgeResultWhereInput[]
|
|
NOT?: JudgeResultWhereInput | JudgeResultWhereInput[]
|
|
submission_id?: StringFilter<"JudgeResult"> | string
|
|
overall_result?: StringFilter<"JudgeResult"> | string
|
|
tests?: JsonFilter<"JudgeResult">
|
|
artifacts?: JsonNullableFilter<"JudgeResult">
|
|
error_classification?: StringNullableFilter<"JudgeResult"> | string | null
|
|
error_signature?: StringNullableFilter<"JudgeResult"> | string | null
|
|
retryable?: BoolFilter<"JudgeResult"> | boolean
|
|
resource_usage?: JsonFilter<"JudgeResult">
|
|
judge_completed_at?: DateTimeFilter<"JudgeResult"> | Date | string
|
|
submission?: XOR<SubmissionScalarRelationFilter, SubmissionWhereInput>
|
|
}, "id">
|
|
|
|
export type JudgeResultOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
submission_id?: SortOrder
|
|
overall_result?: SortOrder
|
|
tests?: SortOrder
|
|
artifacts?: SortOrderInput | SortOrder
|
|
error_classification?: SortOrderInput | SortOrder
|
|
error_signature?: SortOrderInput | SortOrder
|
|
retryable?: SortOrder
|
|
resource_usage?: SortOrder
|
|
judge_completed_at?: SortOrder
|
|
_count?: JudgeResultCountOrderByAggregateInput
|
|
_max?: JudgeResultMaxOrderByAggregateInput
|
|
_min?: JudgeResultMinOrderByAggregateInput
|
|
}
|
|
|
|
export type JudgeResultScalarWhereWithAggregatesInput = {
|
|
AND?: JudgeResultScalarWhereWithAggregatesInput | JudgeResultScalarWhereWithAggregatesInput[]
|
|
OR?: JudgeResultScalarWhereWithAggregatesInput[]
|
|
NOT?: JudgeResultScalarWhereWithAggregatesInput | JudgeResultScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"JudgeResult"> | string
|
|
submission_id?: StringWithAggregatesFilter<"JudgeResult"> | string
|
|
overall_result?: StringWithAggregatesFilter<"JudgeResult"> | string
|
|
tests?: JsonWithAggregatesFilter<"JudgeResult">
|
|
artifacts?: JsonNullableWithAggregatesFilter<"JudgeResult">
|
|
error_classification?: StringNullableWithAggregatesFilter<"JudgeResult"> | string | null
|
|
error_signature?: StringNullableWithAggregatesFilter<"JudgeResult"> | string | null
|
|
retryable?: BoolWithAggregatesFilter<"JudgeResult"> | boolean
|
|
resource_usage?: JsonWithAggregatesFilter<"JudgeResult">
|
|
judge_completed_at?: DateTimeWithAggregatesFilter<"JudgeResult"> | Date | string
|
|
}
|
|
|
|
export type AuditEventWhereInput = {
|
|
AND?: AuditEventWhereInput | AuditEventWhereInput[]
|
|
OR?: AuditEventWhereInput[]
|
|
NOT?: AuditEventWhereInput | AuditEventWhereInput[]
|
|
id?: StringFilter<"AuditEvent"> | string
|
|
actorType?: StringFilter<"AuditEvent"> | string
|
|
actorId?: StringNullableFilter<"AuditEvent"> | string | null
|
|
action?: StringFilter<"AuditEvent"> | string
|
|
entityType?: StringFilter<"AuditEvent"> | string
|
|
entityId?: StringFilter<"AuditEvent"> | string
|
|
beforeState?: JsonNullableFilter<"AuditEvent">
|
|
afterState?: JsonNullableFilter<"AuditEvent">
|
|
reason?: StringNullableFilter<"AuditEvent"> | string | null
|
|
metadata?: JsonNullableFilter<"AuditEvent">
|
|
createdAt?: DateTimeFilter<"AuditEvent"> | Date | string
|
|
}
|
|
|
|
export type AuditEventOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
actorType?: SortOrder
|
|
actorId?: SortOrderInput | SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
beforeState?: SortOrderInput | SortOrder
|
|
afterState?: SortOrderInput | SortOrder
|
|
reason?: SortOrderInput | SortOrder
|
|
metadata?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type AuditEventWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: AuditEventWhereInput | AuditEventWhereInput[]
|
|
OR?: AuditEventWhereInput[]
|
|
NOT?: AuditEventWhereInput | AuditEventWhereInput[]
|
|
actorType?: StringFilter<"AuditEvent"> | string
|
|
actorId?: StringNullableFilter<"AuditEvent"> | string | null
|
|
action?: StringFilter<"AuditEvent"> | string
|
|
entityType?: StringFilter<"AuditEvent"> | string
|
|
entityId?: StringFilter<"AuditEvent"> | string
|
|
beforeState?: JsonNullableFilter<"AuditEvent">
|
|
afterState?: JsonNullableFilter<"AuditEvent">
|
|
reason?: StringNullableFilter<"AuditEvent"> | string | null
|
|
metadata?: JsonNullableFilter<"AuditEvent">
|
|
createdAt?: DateTimeFilter<"AuditEvent"> | Date | string
|
|
}, "id">
|
|
|
|
export type AuditEventOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
actorType?: SortOrder
|
|
actorId?: SortOrderInput | SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
beforeState?: SortOrderInput | SortOrder
|
|
afterState?: SortOrderInput | SortOrder
|
|
reason?: SortOrderInput | SortOrder
|
|
metadata?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: AuditEventCountOrderByAggregateInput
|
|
_max?: AuditEventMaxOrderByAggregateInput
|
|
_min?: AuditEventMinOrderByAggregateInput
|
|
}
|
|
|
|
export type AuditEventScalarWhereWithAggregatesInput = {
|
|
AND?: AuditEventScalarWhereWithAggregatesInput | AuditEventScalarWhereWithAggregatesInput[]
|
|
OR?: AuditEventScalarWhereWithAggregatesInput[]
|
|
NOT?: AuditEventScalarWhereWithAggregatesInput | AuditEventScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"AuditEvent"> | string
|
|
actorType?: StringWithAggregatesFilter<"AuditEvent"> | string
|
|
actorId?: StringNullableWithAggregatesFilter<"AuditEvent"> | string | null
|
|
action?: StringWithAggregatesFilter<"AuditEvent"> | string
|
|
entityType?: StringWithAggregatesFilter<"AuditEvent"> | string
|
|
entityId?: StringWithAggregatesFilter<"AuditEvent"> | string
|
|
beforeState?: JsonNullableWithAggregatesFilter<"AuditEvent">
|
|
afterState?: JsonNullableWithAggregatesFilter<"AuditEvent">
|
|
reason?: StringNullableWithAggregatesFilter<"AuditEvent"> | string | null
|
|
metadata?: JsonNullableWithAggregatesFilter<"AuditEvent">
|
|
createdAt?: DateTimeWithAggregatesFilter<"AuditEvent"> | Date | string
|
|
}
|
|
|
|
export type LedgerEntryWhereInput = {
|
|
AND?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
|
|
OR?: LedgerEntryWhereInput[]
|
|
NOT?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
|
|
id?: StringFilter<"LedgerEntry"> | string
|
|
task_id?: StringFilter<"LedgerEntry"> | string
|
|
phase?: StringFilter<"LedgerEntry"> | string
|
|
idempotency_key?: StringFilter<"LedgerEntry"> | string
|
|
stripe_object_id?: StringNullableFilter<"LedgerEntry"> | string | null
|
|
response_status?: StringFilter<"LedgerEntry"> | string
|
|
http_status?: IntFilter<"LedgerEntry"> | number
|
|
created_at?: DateTimeFilter<"LedgerEntry"> | Date | string
|
|
updated_at?: DateTimeFilter<"LedgerEntry"> | Date | string
|
|
}
|
|
|
|
export type LedgerEntryOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
phase?: SortOrder
|
|
idempotency_key?: SortOrder
|
|
stripe_object_id?: SortOrderInput | SortOrder
|
|
response_status?: SortOrder
|
|
http_status?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type LedgerEntryWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
idempotency_key?: string
|
|
AND?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
|
|
OR?: LedgerEntryWhereInput[]
|
|
NOT?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
|
|
task_id?: StringFilter<"LedgerEntry"> | string
|
|
phase?: StringFilter<"LedgerEntry"> | string
|
|
stripe_object_id?: StringNullableFilter<"LedgerEntry"> | string | null
|
|
response_status?: StringFilter<"LedgerEntry"> | string
|
|
http_status?: IntFilter<"LedgerEntry"> | number
|
|
created_at?: DateTimeFilter<"LedgerEntry"> | Date | string
|
|
updated_at?: DateTimeFilter<"LedgerEntry"> | Date | string
|
|
}, "id" | "idempotency_key">
|
|
|
|
export type LedgerEntryOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
phase?: SortOrder
|
|
idempotency_key?: SortOrder
|
|
stripe_object_id?: SortOrderInput | SortOrder
|
|
response_status?: SortOrder
|
|
http_status?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
_count?: LedgerEntryCountOrderByAggregateInput
|
|
_avg?: LedgerEntryAvgOrderByAggregateInput
|
|
_max?: LedgerEntryMaxOrderByAggregateInput
|
|
_min?: LedgerEntryMinOrderByAggregateInput
|
|
_sum?: LedgerEntrySumOrderByAggregateInput
|
|
}
|
|
|
|
export type LedgerEntryScalarWhereWithAggregatesInput = {
|
|
AND?: LedgerEntryScalarWhereWithAggregatesInput | LedgerEntryScalarWhereWithAggregatesInput[]
|
|
OR?: LedgerEntryScalarWhereWithAggregatesInput[]
|
|
NOT?: LedgerEntryScalarWhereWithAggregatesInput | LedgerEntryScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"LedgerEntry"> | string
|
|
task_id?: StringWithAggregatesFilter<"LedgerEntry"> | string
|
|
phase?: StringWithAggregatesFilter<"LedgerEntry"> | string
|
|
idempotency_key?: StringWithAggregatesFilter<"LedgerEntry"> | string
|
|
stripe_object_id?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
|
|
response_status?: StringWithAggregatesFilter<"LedgerEntry"> | string
|
|
http_status?: IntWithAggregatesFilter<"LedgerEntry"> | number
|
|
created_at?: DateTimeWithAggregatesFilter<"LedgerEntry"> | Date | string
|
|
updated_at?: DateTimeWithAggregatesFilter<"LedgerEntry"> | Date | string
|
|
}
|
|
|
|
export type TaskCreateInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
claims?: ClaimCreateNestedManyWithoutTaskInput
|
|
submissions?: SubmissionCreateNestedManyWithoutTaskInput
|
|
}
|
|
|
|
export type TaskUncheckedCreateInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
claims?: ClaimUncheckedCreateNestedManyWithoutTaskInput
|
|
submissions?: SubmissionUncheckedCreateNestedManyWithoutTaskInput
|
|
}
|
|
|
|
export type TaskUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
claims?: ClaimUpdateManyWithoutTaskNestedInput
|
|
submissions?: SubmissionUpdateManyWithoutTaskNestedInput
|
|
}
|
|
|
|
export type TaskUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
claims?: ClaimUncheckedUpdateManyWithoutTaskNestedInput
|
|
submissions?: SubmissionUncheckedUpdateManyWithoutTaskNestedInput
|
|
}
|
|
|
|
export type TaskCreateManyInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type TaskUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type TaskUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ClaimCreateInput = {
|
|
id?: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
task: TaskCreateNestedOneWithoutClaimsInput
|
|
submissions?: SubmissionCreateNestedManyWithoutClaimInput
|
|
}
|
|
|
|
export type ClaimUncheckedCreateInput = {
|
|
id?: string
|
|
task_id: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
submissions?: SubmissionUncheckedCreateNestedManyWithoutClaimInput
|
|
}
|
|
|
|
export type ClaimUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
task?: TaskUpdateOneRequiredWithoutClaimsNestedInput
|
|
submissions?: SubmissionUpdateManyWithoutClaimNestedInput
|
|
}
|
|
|
|
export type ClaimUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
submissions?: SubmissionUncheckedUpdateManyWithoutClaimNestedInput
|
|
}
|
|
|
|
export type ClaimCreateManyInput = {
|
|
id?: string
|
|
task_id: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type ClaimUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ClaimUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SubmissionCreateInput = {
|
|
id?: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
task: TaskCreateNestedOneWithoutSubmissionsInput
|
|
claim: ClaimCreateNestedOneWithoutSubmissionsInput
|
|
judge_results?: JudgeResultCreateNestedManyWithoutSubmissionInput
|
|
}
|
|
|
|
export type SubmissionUncheckedCreateInput = {
|
|
id?: string
|
|
task_id: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
judge_results?: JudgeResultUncheckedCreateNestedManyWithoutSubmissionInput
|
|
}
|
|
|
|
export type SubmissionUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
task?: TaskUpdateOneRequiredWithoutSubmissionsNestedInput
|
|
claim?: ClaimUpdateOneRequiredWithoutSubmissionsNestedInput
|
|
judge_results?: JudgeResultUpdateManyWithoutSubmissionNestedInput
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
claim_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
judge_results?: JudgeResultUncheckedUpdateManyWithoutSubmissionNestedInput
|
|
}
|
|
|
|
export type SubmissionCreateManyInput = {
|
|
id?: string
|
|
task_id: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type SubmissionUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
claim_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultCreateInput = {
|
|
id?: string
|
|
overall_result: string
|
|
tests: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: string | null
|
|
error_signature?: string | null
|
|
retryable?: boolean
|
|
resource_usage: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: Date | string
|
|
submission: SubmissionCreateNestedOneWithoutJudge_resultsInput
|
|
}
|
|
|
|
export type JudgeResultUncheckedCreateInput = {
|
|
id?: string
|
|
submission_id: string
|
|
overall_result: string
|
|
tests: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: string | null
|
|
error_signature?: string | null
|
|
retryable?: boolean
|
|
resource_usage: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: Date | string
|
|
}
|
|
|
|
export type JudgeResultUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
submission?: SubmissionUpdateOneRequiredWithoutJudge_resultsNestedInput
|
|
}
|
|
|
|
export type JudgeResultUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
submission_id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultCreateManyInput = {
|
|
id?: string
|
|
submission_id: string
|
|
overall_result: string
|
|
tests: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: string | null
|
|
error_signature?: string | null
|
|
retryable?: boolean
|
|
resource_usage: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: Date | string
|
|
}
|
|
|
|
export type JudgeResultUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
submission_id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AuditEventCreateInput = {
|
|
id?: string
|
|
actorType: string
|
|
actorId?: string | null
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AuditEventUncheckedCreateInput = {
|
|
id?: string
|
|
actorType: string
|
|
actorId?: string | null
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AuditEventUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
actorType?: StringFieldUpdateOperationsInput | string
|
|
actorId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: NullableStringFieldUpdateOperationsInput | string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AuditEventUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
actorType?: StringFieldUpdateOperationsInput | string
|
|
actorId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: NullableStringFieldUpdateOperationsInput | string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AuditEventCreateManyInput = {
|
|
id?: string
|
|
actorType: string
|
|
actorId?: string | null
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AuditEventUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
actorType?: StringFieldUpdateOperationsInput | string
|
|
actorId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: NullableStringFieldUpdateOperationsInput | string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AuditEventUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
actorType?: StringFieldUpdateOperationsInput | string
|
|
actorId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
beforeState?: NullableJsonNullValueInput | InputJsonValue
|
|
afterState?: NullableJsonNullValueInput | InputJsonValue
|
|
reason?: NullableStringFieldUpdateOperationsInput | string | null
|
|
metadata?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LedgerEntryCreateInput = {
|
|
id?: string
|
|
task_id: string
|
|
phase: string
|
|
idempotency_key: string
|
|
stripe_object_id?: string | null
|
|
response_status: string
|
|
http_status: number
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type LedgerEntryUncheckedCreateInput = {
|
|
id?: string
|
|
task_id: string
|
|
phase: string
|
|
idempotency_key: string
|
|
stripe_object_id?: string | null
|
|
response_status: string
|
|
http_status: number
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type LedgerEntryUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
phase?: StringFieldUpdateOperationsInput | string
|
|
idempotency_key?: StringFieldUpdateOperationsInput | string
|
|
stripe_object_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
response_status?: StringFieldUpdateOperationsInput | string
|
|
http_status?: IntFieldUpdateOperationsInput | number
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LedgerEntryUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
phase?: StringFieldUpdateOperationsInput | string
|
|
idempotency_key?: StringFieldUpdateOperationsInput | string
|
|
stripe_object_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
response_status?: StringFieldUpdateOperationsInput | string
|
|
http_status?: IntFieldUpdateOperationsInput | number
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LedgerEntryCreateManyInput = {
|
|
id?: string
|
|
task_id: string
|
|
phase: string
|
|
idempotency_key: string
|
|
stripe_object_id?: string | null
|
|
response_status: string
|
|
http_status: number
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type LedgerEntryUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
phase?: StringFieldUpdateOperationsInput | string
|
|
idempotency_key?: StringFieldUpdateOperationsInput | string
|
|
stripe_object_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
response_status?: StringFieldUpdateOperationsInput | string
|
|
http_status?: IntFieldUpdateOperationsInput | number
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LedgerEntryUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
phase?: StringFieldUpdateOperationsInput | string
|
|
idempotency_key?: StringFieldUpdateOperationsInput | string
|
|
stripe_object_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
response_status?: StringFieldUpdateOperationsInput | string
|
|
http_status?: IntFieldUpdateOperationsInput | number
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type StringFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringFilter<$PrismaModel> | string
|
|
}
|
|
|
|
export type FloatFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
lt?: number | FloatFieldRefInput<$PrismaModel>
|
|
lte?: number | FloatFieldRefInput<$PrismaModel>
|
|
gt?: number | FloatFieldRefInput<$PrismaModel>
|
|
gte?: number | FloatFieldRefInput<$PrismaModel>
|
|
not?: NestedFloatFilter<$PrismaModel> | number
|
|
}
|
|
|
|
export type StringNullableFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringNullableFilter<$PrismaModel> | string | null
|
|
}
|
|
|
|
export type IntFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntFilter<$PrismaModel> | number
|
|
}
|
|
export type JsonFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<JsonFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type JsonFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
}
|
|
|
|
export type StringNullableListFilter<$PrismaModel = never> = {
|
|
equals?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
has?: string | StringFieldRefInput<$PrismaModel> | null
|
|
hasEvery?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
hasSome?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
isEmpty?: boolean
|
|
}
|
|
|
|
export type DateTimeNullableFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
|
|
}
|
|
|
|
export type DateTimeFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeFilter<$PrismaModel> | Date | string
|
|
}
|
|
|
|
export type ClaimListRelationFilter = {
|
|
every?: ClaimWhereInput
|
|
some?: ClaimWhereInput
|
|
none?: ClaimWhereInput
|
|
}
|
|
|
|
export type SubmissionListRelationFilter = {
|
|
every?: SubmissionWhereInput
|
|
some?: SubmissionWhereInput
|
|
none?: SubmissionWhereInput
|
|
}
|
|
|
|
export type SortOrderInput = {
|
|
sort: SortOrder
|
|
nulls?: NullsOrder
|
|
}
|
|
|
|
export type ClaimOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type SubmissionOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type TaskCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
status?: SortOrder
|
|
difficulty?: SortOrder
|
|
scope_clarity_score?: SortOrder
|
|
error_classification?: SortOrder
|
|
reward_amount?: SortOrder
|
|
reward_currency?: SortOrder
|
|
acceptance_criteria?: SortOrder
|
|
required_stack?: SortOrder
|
|
retry_count?: SortOrder
|
|
stripe_payment_intent_id?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type TaskAvgOrderByAggregateInput = {
|
|
scope_clarity_score?: SortOrder
|
|
reward_amount?: SortOrder
|
|
retry_count?: SortOrder
|
|
}
|
|
|
|
export type TaskMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
status?: SortOrder
|
|
difficulty?: SortOrder
|
|
scope_clarity_score?: SortOrder
|
|
error_classification?: SortOrder
|
|
reward_amount?: SortOrder
|
|
reward_currency?: SortOrder
|
|
retry_count?: SortOrder
|
|
stripe_payment_intent_id?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type TaskMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
status?: SortOrder
|
|
difficulty?: SortOrder
|
|
scope_clarity_score?: SortOrder
|
|
error_classification?: SortOrder
|
|
reward_amount?: SortOrder
|
|
reward_currency?: SortOrder
|
|
retry_count?: SortOrder
|
|
stripe_payment_intent_id?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type TaskSumOrderByAggregateInput = {
|
|
scope_clarity_score?: SortOrder
|
|
reward_amount?: SortOrder
|
|
retry_count?: SortOrder
|
|
}
|
|
|
|
export type StringWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedStringFilter<$PrismaModel>
|
|
_max?: NestedStringFilter<$PrismaModel>
|
|
}
|
|
|
|
export type FloatWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
lt?: number | FloatFieldRefInput<$PrismaModel>
|
|
lte?: number | FloatFieldRefInput<$PrismaModel>
|
|
gt?: number | FloatFieldRefInput<$PrismaModel>
|
|
gte?: number | FloatFieldRefInput<$PrismaModel>
|
|
not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedFloatFilter<$PrismaModel>
|
|
_min?: NestedFloatFilter<$PrismaModel>
|
|
_max?: NestedFloatFilter<$PrismaModel>
|
|
}
|
|
|
|
export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedStringNullableFilter<$PrismaModel>
|
|
_max?: NestedStringNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type IntWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedIntFilter<$PrismaModel>
|
|
_max?: NestedIntFilter<$PrismaModel>
|
|
}
|
|
export type JsonWithAggregatesFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<JsonWithAggregatesFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedJsonFilter<$PrismaModel>
|
|
_max?: NestedJsonFilter<$PrismaModel>
|
|
}
|
|
|
|
export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
_max?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedDateTimeFilter<$PrismaModel>
|
|
_max?: NestedDateTimeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type TaskScalarRelationFilter = {
|
|
is?: TaskWhereInput
|
|
isNot?: TaskWhereInput
|
|
}
|
|
|
|
export type ClaimCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
developer_wallet?: SortOrder
|
|
status?: SortOrder
|
|
claim_token?: SortOrder
|
|
held_amount?: SortOrder
|
|
held_currency?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type ClaimAvgOrderByAggregateInput = {
|
|
held_amount?: SortOrder
|
|
}
|
|
|
|
export type ClaimMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
developer_wallet?: SortOrder
|
|
status?: SortOrder
|
|
claim_token?: SortOrder
|
|
held_amount?: SortOrder
|
|
held_currency?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type ClaimMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
developer_wallet?: SortOrder
|
|
status?: SortOrder
|
|
claim_token?: SortOrder
|
|
held_amount?: SortOrder
|
|
held_currency?: SortOrder
|
|
expires_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type ClaimSumOrderByAggregateInput = {
|
|
held_amount?: SortOrder
|
|
}
|
|
|
|
export type ClaimScalarRelationFilter = {
|
|
is?: ClaimWhereInput
|
|
isNot?: ClaimWhereInput
|
|
}
|
|
|
|
export type JudgeResultListRelationFilter = {
|
|
every?: JudgeResultWhereInput
|
|
some?: JudgeResultWhereInput
|
|
none?: JudgeResultWhereInput
|
|
}
|
|
|
|
export type JudgeResultOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type SubmissionCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
claim_id?: SortOrder
|
|
status?: SortOrder
|
|
deliverables?: SortOrder
|
|
estimated_judge_complete_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type SubmissionMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
claim_id?: SortOrder
|
|
status?: SortOrder
|
|
estimated_judge_complete_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type SubmissionMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
claim_id?: SortOrder
|
|
status?: SortOrder
|
|
estimated_judge_complete_at?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
export type JsonNullableFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<JsonNullableFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type JsonNullableFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
}
|
|
|
|
export type BoolFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolFilter<$PrismaModel> | boolean
|
|
}
|
|
|
|
export type SubmissionScalarRelationFilter = {
|
|
is?: SubmissionWhereInput
|
|
isNot?: SubmissionWhereInput
|
|
}
|
|
|
|
export type JudgeResultCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
submission_id?: SortOrder
|
|
overall_result?: SortOrder
|
|
tests?: SortOrder
|
|
artifacts?: SortOrder
|
|
error_classification?: SortOrder
|
|
error_signature?: SortOrder
|
|
retryable?: SortOrder
|
|
resource_usage?: SortOrder
|
|
judge_completed_at?: SortOrder
|
|
}
|
|
|
|
export type JudgeResultMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
submission_id?: SortOrder
|
|
overall_result?: SortOrder
|
|
error_classification?: SortOrder
|
|
error_signature?: SortOrder
|
|
retryable?: SortOrder
|
|
judge_completed_at?: SortOrder
|
|
}
|
|
|
|
export type JudgeResultMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
submission_id?: SortOrder
|
|
overall_result?: SortOrder
|
|
error_classification?: SortOrder
|
|
error_signature?: SortOrder
|
|
retryable?: SortOrder
|
|
judge_completed_at?: SortOrder
|
|
}
|
|
export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedJsonNullableFilter<$PrismaModel>
|
|
_max?: NestedJsonNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type BoolWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedBoolFilter<$PrismaModel>
|
|
_max?: NestedBoolFilter<$PrismaModel>
|
|
}
|
|
|
|
export type AuditEventCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
actorType?: SortOrder
|
|
actorId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
beforeState?: SortOrder
|
|
afterState?: SortOrder
|
|
reason?: SortOrder
|
|
metadata?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type AuditEventMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
actorType?: SortOrder
|
|
actorId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
reason?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type AuditEventMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
actorType?: SortOrder
|
|
actorId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
reason?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type LedgerEntryCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
phase?: SortOrder
|
|
idempotency_key?: SortOrder
|
|
stripe_object_id?: SortOrder
|
|
response_status?: SortOrder
|
|
http_status?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type LedgerEntryAvgOrderByAggregateInput = {
|
|
http_status?: SortOrder
|
|
}
|
|
|
|
export type LedgerEntryMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
phase?: SortOrder
|
|
idempotency_key?: SortOrder
|
|
stripe_object_id?: SortOrder
|
|
response_status?: SortOrder
|
|
http_status?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type LedgerEntryMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
task_id?: SortOrder
|
|
phase?: SortOrder
|
|
idempotency_key?: SortOrder
|
|
stripe_object_id?: SortOrder
|
|
response_status?: SortOrder
|
|
http_status?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
}
|
|
|
|
export type LedgerEntrySumOrderByAggregateInput = {
|
|
http_status?: SortOrder
|
|
}
|
|
|
|
export type TaskCreaterequired_stackInput = {
|
|
set: string[]
|
|
}
|
|
|
|
export type ClaimCreateNestedManyWithoutTaskInput = {
|
|
create?: XOR<ClaimCreateWithoutTaskInput, ClaimUncheckedCreateWithoutTaskInput> | ClaimCreateWithoutTaskInput[] | ClaimUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: ClaimCreateOrConnectWithoutTaskInput | ClaimCreateOrConnectWithoutTaskInput[]
|
|
createMany?: ClaimCreateManyTaskInputEnvelope
|
|
connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
}
|
|
|
|
export type SubmissionCreateNestedManyWithoutTaskInput = {
|
|
create?: XOR<SubmissionCreateWithoutTaskInput, SubmissionUncheckedCreateWithoutTaskInput> | SubmissionCreateWithoutTaskInput[] | SubmissionUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutTaskInput | SubmissionCreateOrConnectWithoutTaskInput[]
|
|
createMany?: SubmissionCreateManyTaskInputEnvelope
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
}
|
|
|
|
export type ClaimUncheckedCreateNestedManyWithoutTaskInput = {
|
|
create?: XOR<ClaimCreateWithoutTaskInput, ClaimUncheckedCreateWithoutTaskInput> | ClaimCreateWithoutTaskInput[] | ClaimUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: ClaimCreateOrConnectWithoutTaskInput | ClaimCreateOrConnectWithoutTaskInput[]
|
|
createMany?: ClaimCreateManyTaskInputEnvelope
|
|
connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
}
|
|
|
|
export type SubmissionUncheckedCreateNestedManyWithoutTaskInput = {
|
|
create?: XOR<SubmissionCreateWithoutTaskInput, SubmissionUncheckedCreateWithoutTaskInput> | SubmissionCreateWithoutTaskInput[] | SubmissionUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutTaskInput | SubmissionCreateOrConnectWithoutTaskInput[]
|
|
createMany?: SubmissionCreateManyTaskInputEnvelope
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
}
|
|
|
|
export type StringFieldUpdateOperationsInput = {
|
|
set?: string
|
|
}
|
|
|
|
export type FloatFieldUpdateOperationsInput = {
|
|
set?: number
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type NullableStringFieldUpdateOperationsInput = {
|
|
set?: string | null
|
|
}
|
|
|
|
export type IntFieldUpdateOperationsInput = {
|
|
set?: number
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type TaskUpdaterequired_stackInput = {
|
|
set?: string[]
|
|
push?: string | string[]
|
|
}
|
|
|
|
export type NullableDateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string | null
|
|
}
|
|
|
|
export type DateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string
|
|
}
|
|
|
|
export type ClaimUpdateManyWithoutTaskNestedInput = {
|
|
create?: XOR<ClaimCreateWithoutTaskInput, ClaimUncheckedCreateWithoutTaskInput> | ClaimCreateWithoutTaskInput[] | ClaimUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: ClaimCreateOrConnectWithoutTaskInput | ClaimCreateOrConnectWithoutTaskInput[]
|
|
upsert?: ClaimUpsertWithWhereUniqueWithoutTaskInput | ClaimUpsertWithWhereUniqueWithoutTaskInput[]
|
|
createMany?: ClaimCreateManyTaskInputEnvelope
|
|
set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
update?: ClaimUpdateWithWhereUniqueWithoutTaskInput | ClaimUpdateWithWhereUniqueWithoutTaskInput[]
|
|
updateMany?: ClaimUpdateManyWithWhereWithoutTaskInput | ClaimUpdateManyWithWhereWithoutTaskInput[]
|
|
deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
|
|
}
|
|
|
|
export type SubmissionUpdateManyWithoutTaskNestedInput = {
|
|
create?: XOR<SubmissionCreateWithoutTaskInput, SubmissionUncheckedCreateWithoutTaskInput> | SubmissionCreateWithoutTaskInput[] | SubmissionUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutTaskInput | SubmissionCreateOrConnectWithoutTaskInput[]
|
|
upsert?: SubmissionUpsertWithWhereUniqueWithoutTaskInput | SubmissionUpsertWithWhereUniqueWithoutTaskInput[]
|
|
createMany?: SubmissionCreateManyTaskInputEnvelope
|
|
set?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
disconnect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
delete?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
update?: SubmissionUpdateWithWhereUniqueWithoutTaskInput | SubmissionUpdateWithWhereUniqueWithoutTaskInput[]
|
|
updateMany?: SubmissionUpdateManyWithWhereWithoutTaskInput | SubmissionUpdateManyWithWhereWithoutTaskInput[]
|
|
deleteMany?: SubmissionScalarWhereInput | SubmissionScalarWhereInput[]
|
|
}
|
|
|
|
export type ClaimUncheckedUpdateManyWithoutTaskNestedInput = {
|
|
create?: XOR<ClaimCreateWithoutTaskInput, ClaimUncheckedCreateWithoutTaskInput> | ClaimCreateWithoutTaskInput[] | ClaimUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: ClaimCreateOrConnectWithoutTaskInput | ClaimCreateOrConnectWithoutTaskInput[]
|
|
upsert?: ClaimUpsertWithWhereUniqueWithoutTaskInput | ClaimUpsertWithWhereUniqueWithoutTaskInput[]
|
|
createMany?: ClaimCreateManyTaskInputEnvelope
|
|
set?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
disconnect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
delete?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
connect?: ClaimWhereUniqueInput | ClaimWhereUniqueInput[]
|
|
update?: ClaimUpdateWithWhereUniqueWithoutTaskInput | ClaimUpdateWithWhereUniqueWithoutTaskInput[]
|
|
updateMany?: ClaimUpdateManyWithWhereWithoutTaskInput | ClaimUpdateManyWithWhereWithoutTaskInput[]
|
|
deleteMany?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateManyWithoutTaskNestedInput = {
|
|
create?: XOR<SubmissionCreateWithoutTaskInput, SubmissionUncheckedCreateWithoutTaskInput> | SubmissionCreateWithoutTaskInput[] | SubmissionUncheckedCreateWithoutTaskInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutTaskInput | SubmissionCreateOrConnectWithoutTaskInput[]
|
|
upsert?: SubmissionUpsertWithWhereUniqueWithoutTaskInput | SubmissionUpsertWithWhereUniqueWithoutTaskInput[]
|
|
createMany?: SubmissionCreateManyTaskInputEnvelope
|
|
set?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
disconnect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
delete?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
update?: SubmissionUpdateWithWhereUniqueWithoutTaskInput | SubmissionUpdateWithWhereUniqueWithoutTaskInput[]
|
|
updateMany?: SubmissionUpdateManyWithWhereWithoutTaskInput | SubmissionUpdateManyWithWhereWithoutTaskInput[]
|
|
deleteMany?: SubmissionScalarWhereInput | SubmissionScalarWhereInput[]
|
|
}
|
|
|
|
export type TaskCreateNestedOneWithoutClaimsInput = {
|
|
create?: XOR<TaskCreateWithoutClaimsInput, TaskUncheckedCreateWithoutClaimsInput>
|
|
connectOrCreate?: TaskCreateOrConnectWithoutClaimsInput
|
|
connect?: TaskWhereUniqueInput
|
|
}
|
|
|
|
export type SubmissionCreateNestedManyWithoutClaimInput = {
|
|
create?: XOR<SubmissionCreateWithoutClaimInput, SubmissionUncheckedCreateWithoutClaimInput> | SubmissionCreateWithoutClaimInput[] | SubmissionUncheckedCreateWithoutClaimInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutClaimInput | SubmissionCreateOrConnectWithoutClaimInput[]
|
|
createMany?: SubmissionCreateManyClaimInputEnvelope
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
}
|
|
|
|
export type SubmissionUncheckedCreateNestedManyWithoutClaimInput = {
|
|
create?: XOR<SubmissionCreateWithoutClaimInput, SubmissionUncheckedCreateWithoutClaimInput> | SubmissionCreateWithoutClaimInput[] | SubmissionUncheckedCreateWithoutClaimInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutClaimInput | SubmissionCreateOrConnectWithoutClaimInput[]
|
|
createMany?: SubmissionCreateManyClaimInputEnvelope
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
}
|
|
|
|
export type TaskUpdateOneRequiredWithoutClaimsNestedInput = {
|
|
create?: XOR<TaskCreateWithoutClaimsInput, TaskUncheckedCreateWithoutClaimsInput>
|
|
connectOrCreate?: TaskCreateOrConnectWithoutClaimsInput
|
|
upsert?: TaskUpsertWithoutClaimsInput
|
|
connect?: TaskWhereUniqueInput
|
|
update?: XOR<XOR<TaskUpdateToOneWithWhereWithoutClaimsInput, TaskUpdateWithoutClaimsInput>, TaskUncheckedUpdateWithoutClaimsInput>
|
|
}
|
|
|
|
export type SubmissionUpdateManyWithoutClaimNestedInput = {
|
|
create?: XOR<SubmissionCreateWithoutClaimInput, SubmissionUncheckedCreateWithoutClaimInput> | SubmissionCreateWithoutClaimInput[] | SubmissionUncheckedCreateWithoutClaimInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutClaimInput | SubmissionCreateOrConnectWithoutClaimInput[]
|
|
upsert?: SubmissionUpsertWithWhereUniqueWithoutClaimInput | SubmissionUpsertWithWhereUniqueWithoutClaimInput[]
|
|
createMany?: SubmissionCreateManyClaimInputEnvelope
|
|
set?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
disconnect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
delete?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
update?: SubmissionUpdateWithWhereUniqueWithoutClaimInput | SubmissionUpdateWithWhereUniqueWithoutClaimInput[]
|
|
updateMany?: SubmissionUpdateManyWithWhereWithoutClaimInput | SubmissionUpdateManyWithWhereWithoutClaimInput[]
|
|
deleteMany?: SubmissionScalarWhereInput | SubmissionScalarWhereInput[]
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateManyWithoutClaimNestedInput = {
|
|
create?: XOR<SubmissionCreateWithoutClaimInput, SubmissionUncheckedCreateWithoutClaimInput> | SubmissionCreateWithoutClaimInput[] | SubmissionUncheckedCreateWithoutClaimInput[]
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutClaimInput | SubmissionCreateOrConnectWithoutClaimInput[]
|
|
upsert?: SubmissionUpsertWithWhereUniqueWithoutClaimInput | SubmissionUpsertWithWhereUniqueWithoutClaimInput[]
|
|
createMany?: SubmissionCreateManyClaimInputEnvelope
|
|
set?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
disconnect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
delete?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
connect?: SubmissionWhereUniqueInput | SubmissionWhereUniqueInput[]
|
|
update?: SubmissionUpdateWithWhereUniqueWithoutClaimInput | SubmissionUpdateWithWhereUniqueWithoutClaimInput[]
|
|
updateMany?: SubmissionUpdateManyWithWhereWithoutClaimInput | SubmissionUpdateManyWithWhereWithoutClaimInput[]
|
|
deleteMany?: SubmissionScalarWhereInput | SubmissionScalarWhereInput[]
|
|
}
|
|
|
|
export type TaskCreateNestedOneWithoutSubmissionsInput = {
|
|
create?: XOR<TaskCreateWithoutSubmissionsInput, TaskUncheckedCreateWithoutSubmissionsInput>
|
|
connectOrCreate?: TaskCreateOrConnectWithoutSubmissionsInput
|
|
connect?: TaskWhereUniqueInput
|
|
}
|
|
|
|
export type ClaimCreateNestedOneWithoutSubmissionsInput = {
|
|
create?: XOR<ClaimCreateWithoutSubmissionsInput, ClaimUncheckedCreateWithoutSubmissionsInput>
|
|
connectOrCreate?: ClaimCreateOrConnectWithoutSubmissionsInput
|
|
connect?: ClaimWhereUniqueInput
|
|
}
|
|
|
|
export type JudgeResultCreateNestedManyWithoutSubmissionInput = {
|
|
create?: XOR<JudgeResultCreateWithoutSubmissionInput, JudgeResultUncheckedCreateWithoutSubmissionInput> | JudgeResultCreateWithoutSubmissionInput[] | JudgeResultUncheckedCreateWithoutSubmissionInput[]
|
|
connectOrCreate?: JudgeResultCreateOrConnectWithoutSubmissionInput | JudgeResultCreateOrConnectWithoutSubmissionInput[]
|
|
createMany?: JudgeResultCreateManySubmissionInputEnvelope
|
|
connect?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
}
|
|
|
|
export type JudgeResultUncheckedCreateNestedManyWithoutSubmissionInput = {
|
|
create?: XOR<JudgeResultCreateWithoutSubmissionInput, JudgeResultUncheckedCreateWithoutSubmissionInput> | JudgeResultCreateWithoutSubmissionInput[] | JudgeResultUncheckedCreateWithoutSubmissionInput[]
|
|
connectOrCreate?: JudgeResultCreateOrConnectWithoutSubmissionInput | JudgeResultCreateOrConnectWithoutSubmissionInput[]
|
|
createMany?: JudgeResultCreateManySubmissionInputEnvelope
|
|
connect?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
}
|
|
|
|
export type TaskUpdateOneRequiredWithoutSubmissionsNestedInput = {
|
|
create?: XOR<TaskCreateWithoutSubmissionsInput, TaskUncheckedCreateWithoutSubmissionsInput>
|
|
connectOrCreate?: TaskCreateOrConnectWithoutSubmissionsInput
|
|
upsert?: TaskUpsertWithoutSubmissionsInput
|
|
connect?: TaskWhereUniqueInput
|
|
update?: XOR<XOR<TaskUpdateToOneWithWhereWithoutSubmissionsInput, TaskUpdateWithoutSubmissionsInput>, TaskUncheckedUpdateWithoutSubmissionsInput>
|
|
}
|
|
|
|
export type ClaimUpdateOneRequiredWithoutSubmissionsNestedInput = {
|
|
create?: XOR<ClaimCreateWithoutSubmissionsInput, ClaimUncheckedCreateWithoutSubmissionsInput>
|
|
connectOrCreate?: ClaimCreateOrConnectWithoutSubmissionsInput
|
|
upsert?: ClaimUpsertWithoutSubmissionsInput
|
|
connect?: ClaimWhereUniqueInput
|
|
update?: XOR<XOR<ClaimUpdateToOneWithWhereWithoutSubmissionsInput, ClaimUpdateWithoutSubmissionsInput>, ClaimUncheckedUpdateWithoutSubmissionsInput>
|
|
}
|
|
|
|
export type JudgeResultUpdateManyWithoutSubmissionNestedInput = {
|
|
create?: XOR<JudgeResultCreateWithoutSubmissionInput, JudgeResultUncheckedCreateWithoutSubmissionInput> | JudgeResultCreateWithoutSubmissionInput[] | JudgeResultUncheckedCreateWithoutSubmissionInput[]
|
|
connectOrCreate?: JudgeResultCreateOrConnectWithoutSubmissionInput | JudgeResultCreateOrConnectWithoutSubmissionInput[]
|
|
upsert?: JudgeResultUpsertWithWhereUniqueWithoutSubmissionInput | JudgeResultUpsertWithWhereUniqueWithoutSubmissionInput[]
|
|
createMany?: JudgeResultCreateManySubmissionInputEnvelope
|
|
set?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
disconnect?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
delete?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
connect?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
update?: JudgeResultUpdateWithWhereUniqueWithoutSubmissionInput | JudgeResultUpdateWithWhereUniqueWithoutSubmissionInput[]
|
|
updateMany?: JudgeResultUpdateManyWithWhereWithoutSubmissionInput | JudgeResultUpdateManyWithWhereWithoutSubmissionInput[]
|
|
deleteMany?: JudgeResultScalarWhereInput | JudgeResultScalarWhereInput[]
|
|
}
|
|
|
|
export type JudgeResultUncheckedUpdateManyWithoutSubmissionNestedInput = {
|
|
create?: XOR<JudgeResultCreateWithoutSubmissionInput, JudgeResultUncheckedCreateWithoutSubmissionInput> | JudgeResultCreateWithoutSubmissionInput[] | JudgeResultUncheckedCreateWithoutSubmissionInput[]
|
|
connectOrCreate?: JudgeResultCreateOrConnectWithoutSubmissionInput | JudgeResultCreateOrConnectWithoutSubmissionInput[]
|
|
upsert?: JudgeResultUpsertWithWhereUniqueWithoutSubmissionInput | JudgeResultUpsertWithWhereUniqueWithoutSubmissionInput[]
|
|
createMany?: JudgeResultCreateManySubmissionInputEnvelope
|
|
set?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
disconnect?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
delete?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
connect?: JudgeResultWhereUniqueInput | JudgeResultWhereUniqueInput[]
|
|
update?: JudgeResultUpdateWithWhereUniqueWithoutSubmissionInput | JudgeResultUpdateWithWhereUniqueWithoutSubmissionInput[]
|
|
updateMany?: JudgeResultUpdateManyWithWhereWithoutSubmissionInput | JudgeResultUpdateManyWithWhereWithoutSubmissionInput[]
|
|
deleteMany?: JudgeResultScalarWhereInput | JudgeResultScalarWhereInput[]
|
|
}
|
|
|
|
export type SubmissionCreateNestedOneWithoutJudge_resultsInput = {
|
|
create?: XOR<SubmissionCreateWithoutJudge_resultsInput, SubmissionUncheckedCreateWithoutJudge_resultsInput>
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutJudge_resultsInput
|
|
connect?: SubmissionWhereUniqueInput
|
|
}
|
|
|
|
export type BoolFieldUpdateOperationsInput = {
|
|
set?: boolean
|
|
}
|
|
|
|
export type SubmissionUpdateOneRequiredWithoutJudge_resultsNestedInput = {
|
|
create?: XOR<SubmissionCreateWithoutJudge_resultsInput, SubmissionUncheckedCreateWithoutJudge_resultsInput>
|
|
connectOrCreate?: SubmissionCreateOrConnectWithoutJudge_resultsInput
|
|
upsert?: SubmissionUpsertWithoutJudge_resultsInput
|
|
connect?: SubmissionWhereUniqueInput
|
|
update?: XOR<XOR<SubmissionUpdateToOneWithWhereWithoutJudge_resultsInput, SubmissionUpdateWithoutJudge_resultsInput>, SubmissionUncheckedUpdateWithoutJudge_resultsInput>
|
|
}
|
|
|
|
export type NestedStringFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
not?: NestedStringFilter<$PrismaModel> | string
|
|
}
|
|
|
|
export type NestedFloatFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
lt?: number | FloatFieldRefInput<$PrismaModel>
|
|
lte?: number | FloatFieldRefInput<$PrismaModel>
|
|
gt?: number | FloatFieldRefInput<$PrismaModel>
|
|
gte?: number | FloatFieldRefInput<$PrismaModel>
|
|
not?: NestedFloatFilter<$PrismaModel> | number
|
|
}
|
|
|
|
export type NestedStringNullableFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
not?: NestedStringNullableFilter<$PrismaModel> | string | null
|
|
}
|
|
|
|
export type NestedIntFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntFilter<$PrismaModel> | number
|
|
}
|
|
|
|
export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
|
|
}
|
|
|
|
export type NestedDateTimeFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeFilter<$PrismaModel> | Date | string
|
|
}
|
|
|
|
export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedStringFilter<$PrismaModel>
|
|
_max?: NestedStringFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedFloatWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
lt?: number | FloatFieldRefInput<$PrismaModel>
|
|
lte?: number | FloatFieldRefInput<$PrismaModel>
|
|
gt?: number | FloatFieldRefInput<$PrismaModel>
|
|
gte?: number | FloatFieldRefInput<$PrismaModel>
|
|
not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedFloatFilter<$PrismaModel>
|
|
_min?: NestedFloatFilter<$PrismaModel>
|
|
_max?: NestedFloatFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedStringNullableFilter<$PrismaModel>
|
|
_max?: NestedStringNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedIntNullableFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel> | null
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntNullableFilter<$PrismaModel> | number | null
|
|
}
|
|
|
|
export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedIntFilter<$PrismaModel>
|
|
_max?: NestedIntFilter<$PrismaModel>
|
|
}
|
|
export type NestedJsonFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<NestedJsonFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type NestedJsonFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
}
|
|
|
|
export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
_max?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedDateTimeFilter<$PrismaModel>
|
|
_max?: NestedDateTimeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedBoolFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolFilter<$PrismaModel> | boolean
|
|
}
|
|
export type NestedJsonNullableFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<NestedJsonNullableFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
}
|
|
|
|
export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedBoolFilter<$PrismaModel>
|
|
_max?: NestedBoolFilter<$PrismaModel>
|
|
}
|
|
|
|
export type ClaimCreateWithoutTaskInput = {
|
|
id?: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
submissions?: SubmissionCreateNestedManyWithoutClaimInput
|
|
}
|
|
|
|
export type ClaimUncheckedCreateWithoutTaskInput = {
|
|
id?: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
submissions?: SubmissionUncheckedCreateNestedManyWithoutClaimInput
|
|
}
|
|
|
|
export type ClaimCreateOrConnectWithoutTaskInput = {
|
|
where: ClaimWhereUniqueInput
|
|
create: XOR<ClaimCreateWithoutTaskInput, ClaimUncheckedCreateWithoutTaskInput>
|
|
}
|
|
|
|
export type ClaimCreateManyTaskInputEnvelope = {
|
|
data: ClaimCreateManyTaskInput | ClaimCreateManyTaskInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type SubmissionCreateWithoutTaskInput = {
|
|
id?: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
claim: ClaimCreateNestedOneWithoutSubmissionsInput
|
|
judge_results?: JudgeResultCreateNestedManyWithoutSubmissionInput
|
|
}
|
|
|
|
export type SubmissionUncheckedCreateWithoutTaskInput = {
|
|
id?: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
judge_results?: JudgeResultUncheckedCreateNestedManyWithoutSubmissionInput
|
|
}
|
|
|
|
export type SubmissionCreateOrConnectWithoutTaskInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
create: XOR<SubmissionCreateWithoutTaskInput, SubmissionUncheckedCreateWithoutTaskInput>
|
|
}
|
|
|
|
export type SubmissionCreateManyTaskInputEnvelope = {
|
|
data: SubmissionCreateManyTaskInput | SubmissionCreateManyTaskInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ClaimUpsertWithWhereUniqueWithoutTaskInput = {
|
|
where: ClaimWhereUniqueInput
|
|
update: XOR<ClaimUpdateWithoutTaskInput, ClaimUncheckedUpdateWithoutTaskInput>
|
|
create: XOR<ClaimCreateWithoutTaskInput, ClaimUncheckedCreateWithoutTaskInput>
|
|
}
|
|
|
|
export type ClaimUpdateWithWhereUniqueWithoutTaskInput = {
|
|
where: ClaimWhereUniqueInput
|
|
data: XOR<ClaimUpdateWithoutTaskInput, ClaimUncheckedUpdateWithoutTaskInput>
|
|
}
|
|
|
|
export type ClaimUpdateManyWithWhereWithoutTaskInput = {
|
|
where: ClaimScalarWhereInput
|
|
data: XOR<ClaimUpdateManyMutationInput, ClaimUncheckedUpdateManyWithoutTaskInput>
|
|
}
|
|
|
|
export type ClaimScalarWhereInput = {
|
|
AND?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
|
|
OR?: ClaimScalarWhereInput[]
|
|
NOT?: ClaimScalarWhereInput | ClaimScalarWhereInput[]
|
|
id?: StringFilter<"Claim"> | string
|
|
task_id?: StringFilter<"Claim"> | string
|
|
developer_wallet?: StringFilter<"Claim"> | string
|
|
status?: StringFilter<"Claim"> | string
|
|
claim_token?: StringFilter<"Claim"> | string
|
|
held_amount?: IntFilter<"Claim"> | number
|
|
held_currency?: StringFilter<"Claim"> | string
|
|
expires_at?: DateTimeFilter<"Claim"> | Date | string
|
|
created_at?: DateTimeFilter<"Claim"> | Date | string
|
|
updated_at?: DateTimeFilter<"Claim"> | Date | string
|
|
}
|
|
|
|
export type SubmissionUpsertWithWhereUniqueWithoutTaskInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
update: XOR<SubmissionUpdateWithoutTaskInput, SubmissionUncheckedUpdateWithoutTaskInput>
|
|
create: XOR<SubmissionCreateWithoutTaskInput, SubmissionUncheckedCreateWithoutTaskInput>
|
|
}
|
|
|
|
export type SubmissionUpdateWithWhereUniqueWithoutTaskInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
data: XOR<SubmissionUpdateWithoutTaskInput, SubmissionUncheckedUpdateWithoutTaskInput>
|
|
}
|
|
|
|
export type SubmissionUpdateManyWithWhereWithoutTaskInput = {
|
|
where: SubmissionScalarWhereInput
|
|
data: XOR<SubmissionUpdateManyMutationInput, SubmissionUncheckedUpdateManyWithoutTaskInput>
|
|
}
|
|
|
|
export type SubmissionScalarWhereInput = {
|
|
AND?: SubmissionScalarWhereInput | SubmissionScalarWhereInput[]
|
|
OR?: SubmissionScalarWhereInput[]
|
|
NOT?: SubmissionScalarWhereInput | SubmissionScalarWhereInput[]
|
|
id?: StringFilter<"Submission"> | string
|
|
task_id?: StringFilter<"Submission"> | string
|
|
claim_id?: StringFilter<"Submission"> | string
|
|
status?: StringFilter<"Submission"> | string
|
|
deliverables?: JsonFilter<"Submission">
|
|
estimated_judge_complete_at?: DateTimeNullableFilter<"Submission"> | Date | string | null
|
|
created_at?: DateTimeFilter<"Submission"> | Date | string
|
|
updated_at?: DateTimeFilter<"Submission"> | Date | string
|
|
}
|
|
|
|
export type TaskCreateWithoutClaimsInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
submissions?: SubmissionCreateNestedManyWithoutTaskInput
|
|
}
|
|
|
|
export type TaskUncheckedCreateWithoutClaimsInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
submissions?: SubmissionUncheckedCreateNestedManyWithoutTaskInput
|
|
}
|
|
|
|
export type TaskCreateOrConnectWithoutClaimsInput = {
|
|
where: TaskWhereUniqueInput
|
|
create: XOR<TaskCreateWithoutClaimsInput, TaskUncheckedCreateWithoutClaimsInput>
|
|
}
|
|
|
|
export type SubmissionCreateWithoutClaimInput = {
|
|
id?: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
task: TaskCreateNestedOneWithoutSubmissionsInput
|
|
judge_results?: JudgeResultCreateNestedManyWithoutSubmissionInput
|
|
}
|
|
|
|
export type SubmissionUncheckedCreateWithoutClaimInput = {
|
|
id?: string
|
|
task_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
judge_results?: JudgeResultUncheckedCreateNestedManyWithoutSubmissionInput
|
|
}
|
|
|
|
export type SubmissionCreateOrConnectWithoutClaimInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
create: XOR<SubmissionCreateWithoutClaimInput, SubmissionUncheckedCreateWithoutClaimInput>
|
|
}
|
|
|
|
export type SubmissionCreateManyClaimInputEnvelope = {
|
|
data: SubmissionCreateManyClaimInput | SubmissionCreateManyClaimInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type TaskUpsertWithoutClaimsInput = {
|
|
update: XOR<TaskUpdateWithoutClaimsInput, TaskUncheckedUpdateWithoutClaimsInput>
|
|
create: XOR<TaskCreateWithoutClaimsInput, TaskUncheckedCreateWithoutClaimsInput>
|
|
where?: TaskWhereInput
|
|
}
|
|
|
|
export type TaskUpdateToOneWithWhereWithoutClaimsInput = {
|
|
where?: TaskWhereInput
|
|
data: XOR<TaskUpdateWithoutClaimsInput, TaskUncheckedUpdateWithoutClaimsInput>
|
|
}
|
|
|
|
export type TaskUpdateWithoutClaimsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
submissions?: SubmissionUpdateManyWithoutTaskNestedInput
|
|
}
|
|
|
|
export type TaskUncheckedUpdateWithoutClaimsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
submissions?: SubmissionUncheckedUpdateManyWithoutTaskNestedInput
|
|
}
|
|
|
|
export type SubmissionUpsertWithWhereUniqueWithoutClaimInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
update: XOR<SubmissionUpdateWithoutClaimInput, SubmissionUncheckedUpdateWithoutClaimInput>
|
|
create: XOR<SubmissionCreateWithoutClaimInput, SubmissionUncheckedCreateWithoutClaimInput>
|
|
}
|
|
|
|
export type SubmissionUpdateWithWhereUniqueWithoutClaimInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
data: XOR<SubmissionUpdateWithoutClaimInput, SubmissionUncheckedUpdateWithoutClaimInput>
|
|
}
|
|
|
|
export type SubmissionUpdateManyWithWhereWithoutClaimInput = {
|
|
where: SubmissionScalarWhereInput
|
|
data: XOR<SubmissionUpdateManyMutationInput, SubmissionUncheckedUpdateManyWithoutClaimInput>
|
|
}
|
|
|
|
export type TaskCreateWithoutSubmissionsInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
claims?: ClaimCreateNestedManyWithoutTaskInput
|
|
}
|
|
|
|
export type TaskUncheckedCreateWithoutSubmissionsInput = {
|
|
id?: string
|
|
title: string
|
|
description: string
|
|
status: string
|
|
difficulty: string
|
|
scope_clarity_score: number
|
|
error_classification?: string | null
|
|
reward_amount: number
|
|
reward_currency: string
|
|
acceptance_criteria: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskCreaterequired_stackInput | string[]
|
|
retry_count?: number
|
|
stripe_payment_intent_id?: string | null
|
|
expires_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
claims?: ClaimUncheckedCreateNestedManyWithoutTaskInput
|
|
}
|
|
|
|
export type TaskCreateOrConnectWithoutSubmissionsInput = {
|
|
where: TaskWhereUniqueInput
|
|
create: XOR<TaskCreateWithoutSubmissionsInput, TaskUncheckedCreateWithoutSubmissionsInput>
|
|
}
|
|
|
|
export type ClaimCreateWithoutSubmissionsInput = {
|
|
id?: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
task: TaskCreateNestedOneWithoutClaimsInput
|
|
}
|
|
|
|
export type ClaimUncheckedCreateWithoutSubmissionsInput = {
|
|
id?: string
|
|
task_id: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type ClaimCreateOrConnectWithoutSubmissionsInput = {
|
|
where: ClaimWhereUniqueInput
|
|
create: XOR<ClaimCreateWithoutSubmissionsInput, ClaimUncheckedCreateWithoutSubmissionsInput>
|
|
}
|
|
|
|
export type JudgeResultCreateWithoutSubmissionInput = {
|
|
id?: string
|
|
overall_result: string
|
|
tests: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: string | null
|
|
error_signature?: string | null
|
|
retryable?: boolean
|
|
resource_usage: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: Date | string
|
|
}
|
|
|
|
export type JudgeResultUncheckedCreateWithoutSubmissionInput = {
|
|
id?: string
|
|
overall_result: string
|
|
tests: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: string | null
|
|
error_signature?: string | null
|
|
retryable?: boolean
|
|
resource_usage: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: Date | string
|
|
}
|
|
|
|
export type JudgeResultCreateOrConnectWithoutSubmissionInput = {
|
|
where: JudgeResultWhereUniqueInput
|
|
create: XOR<JudgeResultCreateWithoutSubmissionInput, JudgeResultUncheckedCreateWithoutSubmissionInput>
|
|
}
|
|
|
|
export type JudgeResultCreateManySubmissionInputEnvelope = {
|
|
data: JudgeResultCreateManySubmissionInput | JudgeResultCreateManySubmissionInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type TaskUpsertWithoutSubmissionsInput = {
|
|
update: XOR<TaskUpdateWithoutSubmissionsInput, TaskUncheckedUpdateWithoutSubmissionsInput>
|
|
create: XOR<TaskCreateWithoutSubmissionsInput, TaskUncheckedCreateWithoutSubmissionsInput>
|
|
where?: TaskWhereInput
|
|
}
|
|
|
|
export type TaskUpdateToOneWithWhereWithoutSubmissionsInput = {
|
|
where?: TaskWhereInput
|
|
data: XOR<TaskUpdateWithoutSubmissionsInput, TaskUncheckedUpdateWithoutSubmissionsInput>
|
|
}
|
|
|
|
export type TaskUpdateWithoutSubmissionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
claims?: ClaimUpdateManyWithoutTaskNestedInput
|
|
}
|
|
|
|
export type TaskUncheckedUpdateWithoutSubmissionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
difficulty?: StringFieldUpdateOperationsInput | string
|
|
scope_clarity_score?: FloatFieldUpdateOperationsInput | number
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
reward_amount?: IntFieldUpdateOperationsInput | number
|
|
reward_currency?: StringFieldUpdateOperationsInput | string
|
|
acceptance_criteria?: JsonNullValueInput | InputJsonValue
|
|
required_stack?: TaskUpdaterequired_stackInput | string[]
|
|
retry_count?: IntFieldUpdateOperationsInput | number
|
|
stripe_payment_intent_id?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
claims?: ClaimUncheckedUpdateManyWithoutTaskNestedInput
|
|
}
|
|
|
|
export type ClaimUpsertWithoutSubmissionsInput = {
|
|
update: XOR<ClaimUpdateWithoutSubmissionsInput, ClaimUncheckedUpdateWithoutSubmissionsInput>
|
|
create: XOR<ClaimCreateWithoutSubmissionsInput, ClaimUncheckedCreateWithoutSubmissionsInput>
|
|
where?: ClaimWhereInput
|
|
}
|
|
|
|
export type ClaimUpdateToOneWithWhereWithoutSubmissionsInput = {
|
|
where?: ClaimWhereInput
|
|
data: XOR<ClaimUpdateWithoutSubmissionsInput, ClaimUncheckedUpdateWithoutSubmissionsInput>
|
|
}
|
|
|
|
export type ClaimUpdateWithoutSubmissionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
task?: TaskUpdateOneRequiredWithoutClaimsNestedInput
|
|
}
|
|
|
|
export type ClaimUncheckedUpdateWithoutSubmissionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultUpsertWithWhereUniqueWithoutSubmissionInput = {
|
|
where: JudgeResultWhereUniqueInput
|
|
update: XOR<JudgeResultUpdateWithoutSubmissionInput, JudgeResultUncheckedUpdateWithoutSubmissionInput>
|
|
create: XOR<JudgeResultCreateWithoutSubmissionInput, JudgeResultUncheckedCreateWithoutSubmissionInput>
|
|
}
|
|
|
|
export type JudgeResultUpdateWithWhereUniqueWithoutSubmissionInput = {
|
|
where: JudgeResultWhereUniqueInput
|
|
data: XOR<JudgeResultUpdateWithoutSubmissionInput, JudgeResultUncheckedUpdateWithoutSubmissionInput>
|
|
}
|
|
|
|
export type JudgeResultUpdateManyWithWhereWithoutSubmissionInput = {
|
|
where: JudgeResultScalarWhereInput
|
|
data: XOR<JudgeResultUpdateManyMutationInput, JudgeResultUncheckedUpdateManyWithoutSubmissionInput>
|
|
}
|
|
|
|
export type JudgeResultScalarWhereInput = {
|
|
AND?: JudgeResultScalarWhereInput | JudgeResultScalarWhereInput[]
|
|
OR?: JudgeResultScalarWhereInput[]
|
|
NOT?: JudgeResultScalarWhereInput | JudgeResultScalarWhereInput[]
|
|
id?: StringFilter<"JudgeResult"> | string
|
|
submission_id?: StringFilter<"JudgeResult"> | string
|
|
overall_result?: StringFilter<"JudgeResult"> | string
|
|
tests?: JsonFilter<"JudgeResult">
|
|
artifacts?: JsonNullableFilter<"JudgeResult">
|
|
error_classification?: StringNullableFilter<"JudgeResult"> | string | null
|
|
error_signature?: StringNullableFilter<"JudgeResult"> | string | null
|
|
retryable?: BoolFilter<"JudgeResult"> | boolean
|
|
resource_usage?: JsonFilter<"JudgeResult">
|
|
judge_completed_at?: DateTimeFilter<"JudgeResult"> | Date | string
|
|
}
|
|
|
|
export type SubmissionCreateWithoutJudge_resultsInput = {
|
|
id?: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
task: TaskCreateNestedOneWithoutSubmissionsInput
|
|
claim: ClaimCreateNestedOneWithoutSubmissionsInput
|
|
}
|
|
|
|
export type SubmissionUncheckedCreateWithoutJudge_resultsInput = {
|
|
id?: string
|
|
task_id: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type SubmissionCreateOrConnectWithoutJudge_resultsInput = {
|
|
where: SubmissionWhereUniqueInput
|
|
create: XOR<SubmissionCreateWithoutJudge_resultsInput, SubmissionUncheckedCreateWithoutJudge_resultsInput>
|
|
}
|
|
|
|
export type SubmissionUpsertWithoutJudge_resultsInput = {
|
|
update: XOR<SubmissionUpdateWithoutJudge_resultsInput, SubmissionUncheckedUpdateWithoutJudge_resultsInput>
|
|
create: XOR<SubmissionCreateWithoutJudge_resultsInput, SubmissionUncheckedCreateWithoutJudge_resultsInput>
|
|
where?: SubmissionWhereInput
|
|
}
|
|
|
|
export type SubmissionUpdateToOneWithWhereWithoutJudge_resultsInput = {
|
|
where?: SubmissionWhereInput
|
|
data: XOR<SubmissionUpdateWithoutJudge_resultsInput, SubmissionUncheckedUpdateWithoutJudge_resultsInput>
|
|
}
|
|
|
|
export type SubmissionUpdateWithoutJudge_resultsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
task?: TaskUpdateOneRequiredWithoutSubmissionsNestedInput
|
|
claim?: ClaimUpdateOneRequiredWithoutSubmissionsNestedInput
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateWithoutJudge_resultsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
claim_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ClaimCreateManyTaskInput = {
|
|
id?: string
|
|
developer_wallet: string
|
|
status: string
|
|
claim_token: string
|
|
held_amount: number
|
|
held_currency: string
|
|
expires_at: Date | string
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type SubmissionCreateManyTaskInput = {
|
|
id?: string
|
|
claim_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type ClaimUpdateWithoutTaskInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
submissions?: SubmissionUpdateManyWithoutClaimNestedInput
|
|
}
|
|
|
|
export type ClaimUncheckedUpdateWithoutTaskInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
submissions?: SubmissionUncheckedUpdateManyWithoutClaimNestedInput
|
|
}
|
|
|
|
export type ClaimUncheckedUpdateManyWithoutTaskInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
developer_wallet?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
claim_token?: StringFieldUpdateOperationsInput | string
|
|
held_amount?: IntFieldUpdateOperationsInput | number
|
|
held_currency?: StringFieldUpdateOperationsInput | string
|
|
expires_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SubmissionUpdateWithoutTaskInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
claim?: ClaimUpdateOneRequiredWithoutSubmissionsNestedInput
|
|
judge_results?: JudgeResultUpdateManyWithoutSubmissionNestedInput
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateWithoutTaskInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
claim_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
judge_results?: JudgeResultUncheckedUpdateManyWithoutSubmissionNestedInput
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateManyWithoutTaskInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
claim_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SubmissionCreateManyClaimInput = {
|
|
id?: string
|
|
task_id: string
|
|
status: string
|
|
deliverables: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: Date | string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
}
|
|
|
|
export type SubmissionUpdateWithoutClaimInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
task?: TaskUpdateOneRequiredWithoutSubmissionsNestedInput
|
|
judge_results?: JudgeResultUpdateManyWithoutSubmissionNestedInput
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateWithoutClaimInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
judge_results?: JudgeResultUncheckedUpdateManyWithoutSubmissionNestedInput
|
|
}
|
|
|
|
export type SubmissionUncheckedUpdateManyWithoutClaimInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
task_id?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
deliverables?: JsonNullValueInput | InputJsonValue
|
|
estimated_judge_complete_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultCreateManySubmissionInput = {
|
|
id?: string
|
|
overall_result: string
|
|
tests: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: string | null
|
|
error_signature?: string | null
|
|
retryable?: boolean
|
|
resource_usage: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: Date | string
|
|
}
|
|
|
|
export type JudgeResultUpdateWithoutSubmissionInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultUncheckedUpdateWithoutSubmissionInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type JudgeResultUncheckedUpdateManyWithoutSubmissionInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
overall_result?: StringFieldUpdateOperationsInput | string
|
|
tests?: JsonNullValueInput | InputJsonValue
|
|
artifacts?: NullableJsonNullValueInput | InputJsonValue
|
|
error_classification?: NullableStringFieldUpdateOperationsInput | string | null
|
|
error_signature?: NullableStringFieldUpdateOperationsInput | string | null
|
|
retryable?: BoolFieldUpdateOperationsInput | boolean
|
|
resource_usage?: JsonNullValueInput | InputJsonValue
|
|
judge_completed_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Batch Payload for updateMany & deleteMany & createMany
|
|
*/
|
|
|
|
export type BatchPayload = {
|
|
count: number
|
|
}
|
|
|
|
/**
|
|
* DMMF
|
|
*/
|
|
export const dmmf: runtime.BaseDMMF
|
|
} |