23412 lines
830 KiB
TypeScript
23412 lines
830 KiB
TypeScript
|
|
/**
|
|
* Client
|
|
**/
|
|
|
|
import * as runtime from '@prisma/client/runtime/library.js';
|
|
import $Types = runtime.Types // general types
|
|
import $Public = runtime.Types.Public
|
|
import $Utils = runtime.Types.Utils
|
|
import $Extensions = runtime.Types.Extensions
|
|
import $Result = runtime.Types.Result
|
|
|
|
export type PrismaPromise<T> = $Public.PrismaPromise<T>
|
|
|
|
|
|
/**
|
|
* Model User
|
|
*
|
|
*/
|
|
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
|
|
/**
|
|
* Model Account
|
|
*
|
|
*/
|
|
export type Account = $Result.DefaultSelection<Prisma.$AccountPayload>
|
|
/**
|
|
* Model Session
|
|
*
|
|
*/
|
|
export type Session = $Result.DefaultSelection<Prisma.$SessionPayload>
|
|
/**
|
|
* Model VerificationToken
|
|
*
|
|
*/
|
|
export type VerificationToken = $Result.DefaultSelection<Prisma.$VerificationTokenPayload>
|
|
/**
|
|
* Model Course
|
|
*
|
|
*/
|
|
export type Course = $Result.DefaultSelection<Prisma.$CoursePayload>
|
|
/**
|
|
* Model Module
|
|
*
|
|
*/
|
|
export type Module = $Result.DefaultSelection<Prisma.$ModulePayload>
|
|
/**
|
|
* Model Lesson
|
|
*
|
|
*/
|
|
export type Lesson = $Result.DefaultSelection<Prisma.$LessonPayload>
|
|
/**
|
|
* Model Quiz
|
|
*
|
|
*/
|
|
export type Quiz = $Result.DefaultSelection<Prisma.$QuizPayload>
|
|
/**
|
|
* Model Question
|
|
*
|
|
*/
|
|
export type Question = $Result.DefaultSelection<Prisma.$QuestionPayload>
|
|
/**
|
|
* Model Enrollment
|
|
*
|
|
*/
|
|
export type Enrollment = $Result.DefaultSelection<Prisma.$EnrollmentPayload>
|
|
/**
|
|
* Model LessonProgress
|
|
*
|
|
*/
|
|
export type LessonProgress = $Result.DefaultSelection<Prisma.$LessonProgressPayload>
|
|
/**
|
|
* Model QuizAttempt
|
|
*
|
|
*/
|
|
export type QuizAttempt = $Result.DefaultSelection<Prisma.$QuizAttemptPayload>
|
|
/**
|
|
* Model Certificate
|
|
*
|
|
*/
|
|
export type Certificate = $Result.DefaultSelection<Prisma.$CertificatePayload>
|
|
|
|
/**
|
|
* Enums
|
|
*/
|
|
export namespace $Enums {
|
|
export const Role: {
|
|
ADMIN: 'ADMIN',
|
|
LEARNER: 'LEARNER'
|
|
};
|
|
|
|
export type Role = (typeof Role)[keyof typeof Role]
|
|
|
|
|
|
export const CourseCategory: {
|
|
GOVERNANCE: 'GOVERNANCE',
|
|
CYBER: 'CYBER',
|
|
OWLCUB: 'OWLCUB',
|
|
OTHER: 'OTHER'
|
|
};
|
|
|
|
export type CourseCategory = (typeof CourseCategory)[keyof typeof CourseCategory]
|
|
|
|
|
|
export const CourseLevel: {
|
|
BEGINNER: 'BEGINNER',
|
|
INTERMEDIATE: 'INTERMEDIATE',
|
|
ADVANCED: 'ADVANCED'
|
|
};
|
|
|
|
export type CourseLevel = (typeof CourseLevel)[keyof typeof CourseLevel]
|
|
|
|
|
|
export const LessonType: {
|
|
VIDEO: 'VIDEO',
|
|
TEXT: 'TEXT'
|
|
};
|
|
|
|
export type LessonType = (typeof LessonType)[keyof typeof LessonType]
|
|
|
|
}
|
|
|
|
export type Role = $Enums.Role
|
|
|
|
export const Role: typeof $Enums.Role
|
|
|
|
export type CourseCategory = $Enums.CourseCategory
|
|
|
|
export const CourseCategory: typeof $Enums.CourseCategory
|
|
|
|
export type CourseLevel = $Enums.CourseLevel
|
|
|
|
export const CourseLevel: typeof $Enums.CourseLevel
|
|
|
|
export type LessonType = $Enums.LessonType
|
|
|
|
export const LessonType: typeof $Enums.LessonType
|
|
|
|
/**
|
|
* ## Prisma Client ʲˢ
|
|
*
|
|
* Type-safe database client for TypeScript & Node.js
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient()
|
|
* // Fetch zero or more Users
|
|
* const users = await prisma.user.findMany()
|
|
* ```
|
|
*
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
|
|
*/
|
|
export class PrismaClient<
|
|
ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
|
|
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()
|
|
* // Fetch zero or more Users
|
|
* const users = await prisma.user.findMany()
|
|
* ```
|
|
*
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
|
|
*/
|
|
|
|
constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
|
|
$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): 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://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
|
|
|
|
/**
|
|
* Executes a raw query and returns the number of affected rows.
|
|
* Susceptible to SQL injections, see documentation.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
|
|
|
|
/**
|
|
* Performs a prepared raw query and returns the `SELECT` data.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
|
|
|
|
/**
|
|
* Performs a raw query and returns the `SELECT` data.
|
|
* Susceptible to SQL injections, see documentation.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
|
|
|
|
|
|
/**
|
|
* Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
|
|
* @example
|
|
* ```
|
|
* const [george, bob, alice] = await prisma.$transaction([
|
|
* prisma.user.create({ data: { name: 'George' } }),
|
|
* prisma.user.create({ data: { name: 'Bob' } }),
|
|
* prisma.user.create({ data: { name: 'Alice' } }),
|
|
* ])
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
|
|
*/
|
|
$transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>
|
|
|
|
$transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => $Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<R>
|
|
|
|
|
|
$extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<ClientOptions>, ExtArgs, $Utils.Call<Prisma.TypeMapCb<ClientOptions>, {
|
|
extArgs: ExtArgs
|
|
}>>
|
|
|
|
/**
|
|
* `prisma.user`: Exposes CRUD operations for the **User** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Users
|
|
* const users = await prisma.user.findMany()
|
|
* ```
|
|
*/
|
|
get user(): Prisma.UserDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.account`: Exposes CRUD operations for the **Account** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Accounts
|
|
* const accounts = await prisma.account.findMany()
|
|
* ```
|
|
*/
|
|
get account(): Prisma.AccountDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.session`: Exposes CRUD operations for the **Session** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Sessions
|
|
* const sessions = await prisma.session.findMany()
|
|
* ```
|
|
*/
|
|
get session(): Prisma.SessionDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.verificationToken`: Exposes CRUD operations for the **VerificationToken** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more VerificationTokens
|
|
* const verificationTokens = await prisma.verificationToken.findMany()
|
|
* ```
|
|
*/
|
|
get verificationToken(): Prisma.VerificationTokenDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.course`: Exposes CRUD operations for the **Course** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Courses
|
|
* const courses = await prisma.course.findMany()
|
|
* ```
|
|
*/
|
|
get course(): Prisma.CourseDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.module`: Exposes CRUD operations for the **Module** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Modules
|
|
* const modules = await prisma.module.findMany()
|
|
* ```
|
|
*/
|
|
get module(): Prisma.ModuleDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.lesson`: Exposes CRUD operations for the **Lesson** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Lessons
|
|
* const lessons = await prisma.lesson.findMany()
|
|
* ```
|
|
*/
|
|
get lesson(): Prisma.LessonDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.quiz`: Exposes CRUD operations for the **Quiz** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Quizzes
|
|
* const quizzes = await prisma.quiz.findMany()
|
|
* ```
|
|
*/
|
|
get quiz(): Prisma.QuizDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.question`: Exposes CRUD operations for the **Question** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Questions
|
|
* const questions = await prisma.question.findMany()
|
|
* ```
|
|
*/
|
|
get question(): Prisma.QuestionDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.enrollment`: Exposes CRUD operations for the **Enrollment** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Enrollments
|
|
* const enrollments = await prisma.enrollment.findMany()
|
|
* ```
|
|
*/
|
|
get enrollment(): Prisma.EnrollmentDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.lessonProgress`: Exposes CRUD operations for the **LessonProgress** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more LessonProgresses
|
|
* const lessonProgresses = await prisma.lessonProgress.findMany()
|
|
* ```
|
|
*/
|
|
get lessonProgress(): Prisma.LessonProgressDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.quizAttempt`: Exposes CRUD operations for the **QuizAttempt** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more QuizAttempts
|
|
* const quizAttempts = await prisma.quizAttempt.findMany()
|
|
* ```
|
|
*/
|
|
get quizAttempt(): Prisma.QuizAttemptDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.certificate`: Exposes CRUD operations for the **Certificate** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Certificates
|
|
* const certificates = await prisma.certificate.findMany()
|
|
* ```
|
|
*/
|
|
get certificate(): Prisma.CertificateDelegate<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
|
|
|
|
/**
|
|
* Metrics
|
|
*/
|
|
export type Metrics = runtime.Metrics
|
|
export type Metric<T> = runtime.Metric<T>
|
|
export type MetricHistogram = runtime.MetricHistogram
|
|
export type MetricHistogramBucket = runtime.MetricHistogramBucket
|
|
|
|
/**
|
|
* Extensions
|
|
*/
|
|
export import Extension = $Extensions.UserArgs
|
|
export import getExtensionContext = runtime.Extensions.getExtensionContext
|
|
export import Args = $Public.Args
|
|
export import Payload = $Public.Payload
|
|
export import Result = $Public.Result
|
|
export import Exact = $Public.Exact
|
|
|
|
/**
|
|
* Prisma Client JS version: 6.19.2
|
|
* Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7
|
|
*/
|
|
export type PrismaVersion = {
|
|
client: 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: {
|
|
User: 'User',
|
|
Account: 'Account',
|
|
Session: 'Session',
|
|
VerificationToken: 'VerificationToken',
|
|
Course: 'Course',
|
|
Module: 'Module',
|
|
Lesson: 'Lesson',
|
|
Quiz: 'Quiz',
|
|
Question: 'Question',
|
|
Enrollment: 'Enrollment',
|
|
LessonProgress: 'LessonProgress',
|
|
QuizAttempt: 'QuizAttempt',
|
|
Certificate: 'Certificate'
|
|
};
|
|
|
|
export type ModelName = (typeof ModelName)[keyof typeof ModelName]
|
|
|
|
|
|
export type Datasources = {
|
|
db?: Datasource
|
|
}
|
|
|
|
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: "user" | "account" | "session" | "verificationToken" | "course" | "module" | "lesson" | "quiz" | "question" | "enrollment" | "lessonProgress" | "quizAttempt" | "certificate"
|
|
txIsolationLevel: Prisma.TransactionIsolationLevel
|
|
}
|
|
model: {
|
|
User: {
|
|
payload: Prisma.$UserPayload<ExtArgs>
|
|
fields: Prisma.UserFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.UserFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.UserFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.UserFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.UserCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.UserCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.UserDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.UserUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.UserDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.UserUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.UserUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.UserAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateUser>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.UserGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<UserGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.UserCountArgs<ExtArgs>
|
|
result: $Utils.Optional<UserCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Account: {
|
|
payload: Prisma.$AccountPayload<ExtArgs>
|
|
fields: Prisma.AccountFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.AccountFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.AccountFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.AccountFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.AccountFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.AccountFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.AccountCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.AccountCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.AccountCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.AccountDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.AccountUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.AccountDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.AccountUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.AccountUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.AccountUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AccountPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.AccountAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateAccount>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.AccountGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<AccountGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.AccountCountArgs<ExtArgs>
|
|
result: $Utils.Optional<AccountCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Session: {
|
|
payload: Prisma.$SessionPayload<ExtArgs>
|
|
fields: Prisma.SessionFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.SessionFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.SessionFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.SessionFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.SessionCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.SessionCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.SessionDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.SessionUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.SessionDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.SessionUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.SessionUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SessionPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.SessionAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateSession>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.SessionGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<SessionGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.SessionCountArgs<ExtArgs>
|
|
result: $Utils.Optional<SessionCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
VerificationToken: {
|
|
payload: Prisma.$VerificationTokenPayload<ExtArgs>
|
|
fields: Prisma.VerificationTokenFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.VerificationTokenFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.VerificationTokenFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.VerificationTokenFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.VerificationTokenFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.VerificationTokenFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.VerificationTokenCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.VerificationTokenCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.VerificationTokenCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.VerificationTokenDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.VerificationTokenUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.VerificationTokenDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.VerificationTokenUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.VerificationTokenUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.VerificationTokenUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.VerificationTokenAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateVerificationToken>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.VerificationTokenGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<VerificationTokenGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.VerificationTokenCountArgs<ExtArgs>
|
|
result: $Utils.Optional<VerificationTokenCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Course: {
|
|
payload: Prisma.$CoursePayload<ExtArgs>
|
|
fields: Prisma.CourseFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.CourseFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.CourseFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.CourseFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.CourseFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.CourseFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.CourseCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.CourseCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.CourseCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.CourseDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>
|
|
}
|
|
update: {
|
|
args: Prisma.CourseUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.CourseDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.CourseUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.CourseUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.CourseUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CoursePayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.CourseAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateCourse>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.CourseGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<CourseGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.CourseCountArgs<ExtArgs>
|
|
result: $Utils.Optional<CourseCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Module: {
|
|
payload: Prisma.$ModulePayload<ExtArgs>
|
|
fields: Prisma.ModuleFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.ModuleFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.ModuleFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.ModuleFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.ModuleFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.ModuleFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.ModuleCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.ModuleCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.ModuleCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.ModuleDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>
|
|
}
|
|
update: {
|
|
args: Prisma.ModuleUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.ModuleDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.ModuleUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.ModuleUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.ModuleUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ModulePayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.ModuleAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateModule>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.ModuleGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<ModuleGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.ModuleCountArgs<ExtArgs>
|
|
result: $Utils.Optional<ModuleCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Lesson: {
|
|
payload: Prisma.$LessonPayload<ExtArgs>
|
|
fields: Prisma.LessonFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.LessonFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.LessonFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.LessonFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.LessonFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.LessonFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.LessonCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.LessonCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.LessonCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.LessonDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.LessonUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.LessonDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.LessonUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.LessonUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.LessonUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.LessonAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateLesson>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.LessonGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<LessonGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.LessonCountArgs<ExtArgs>
|
|
result: $Utils.Optional<LessonCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Quiz: {
|
|
payload: Prisma.$QuizPayload<ExtArgs>
|
|
fields: Prisma.QuizFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.QuizFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.QuizFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.QuizFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.QuizFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.QuizFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.QuizCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.QuizCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.QuizCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.QuizDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.QuizUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.QuizDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.QuizUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.QuizUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.QuizUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.QuizAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateQuiz>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.QuizGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<QuizGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.QuizCountArgs<ExtArgs>
|
|
result: $Utils.Optional<QuizCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Question: {
|
|
payload: Prisma.$QuestionPayload<ExtArgs>
|
|
fields: Prisma.QuestionFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.QuestionFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.QuestionFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.QuestionFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.QuestionFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.QuestionFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.QuestionCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.QuestionCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.QuestionCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.QuestionDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.QuestionUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.QuestionDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.QuestionUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.QuestionUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.QuestionUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuestionPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.QuestionAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateQuestion>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.QuestionGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<QuestionGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.QuestionCountArgs<ExtArgs>
|
|
result: $Utils.Optional<QuestionCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Enrollment: {
|
|
payload: Prisma.$EnrollmentPayload<ExtArgs>
|
|
fields: Prisma.EnrollmentFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.EnrollmentFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.EnrollmentFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.EnrollmentFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.EnrollmentFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.EnrollmentFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.EnrollmentCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.EnrollmentCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.EnrollmentCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.EnrollmentDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.EnrollmentUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.EnrollmentDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.EnrollmentUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.EnrollmentUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.EnrollmentUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EnrollmentPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.EnrollmentAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateEnrollment>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.EnrollmentGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<EnrollmentGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.EnrollmentCountArgs<ExtArgs>
|
|
result: $Utils.Optional<EnrollmentCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
LessonProgress: {
|
|
payload: Prisma.$LessonProgressPayload<ExtArgs>
|
|
fields: Prisma.LessonProgressFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.LessonProgressFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.LessonProgressFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.LessonProgressFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.LessonProgressFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.LessonProgressFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.LessonProgressCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.LessonProgressCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.LessonProgressCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.LessonProgressDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.LessonProgressUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.LessonProgressDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.LessonProgressUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.LessonProgressUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.LessonProgressUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$LessonProgressPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.LessonProgressAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateLessonProgress>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.LessonProgressGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<LessonProgressGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.LessonProgressCountArgs<ExtArgs>
|
|
result: $Utils.Optional<LessonProgressCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
QuizAttempt: {
|
|
payload: Prisma.$QuizAttemptPayload<ExtArgs>
|
|
fields: Prisma.QuizAttemptFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.QuizAttemptFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.QuizAttemptFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.QuizAttemptFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.QuizAttemptFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.QuizAttemptFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.QuizAttemptCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.QuizAttemptCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.QuizAttemptCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.QuizAttemptDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.QuizAttemptUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.QuizAttemptDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.QuizAttemptUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.QuizAttemptUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.QuizAttemptUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$QuizAttemptPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.QuizAttemptAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateQuizAttempt>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.QuizAttemptGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<QuizAttemptGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.QuizAttemptCountArgs<ExtArgs>
|
|
result: $Utils.Optional<QuizAttemptCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Certificate: {
|
|
payload: Prisma.$CertificatePayload<ExtArgs>
|
|
fields: Prisma.CertificateFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.CertificateFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.CertificateFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.CertificateFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.CertificateFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.CertificateFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.CertificateCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.CertificateCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.CertificateCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.CertificateDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>
|
|
}
|
|
update: {
|
|
args: Prisma.CertificateUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.CertificateDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.CertificateUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.CertificateUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.CertificateUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CertificatePayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.CertificateAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateCertificate>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.CertificateGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<CertificateGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.CertificateCountArgs<ExtArgs>
|
|
result: $Utils.Optional<CertificateCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} & {
|
|
other: {
|
|
payload: any
|
|
operations: {
|
|
$executeRaw: {
|
|
args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
|
|
result: any
|
|
}
|
|
$executeRawUnsafe: {
|
|
args: [query: string, ...values: any[]],
|
|
result: any
|
|
}
|
|
$queryRaw: {
|
|
args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
|
|
result: any
|
|
}
|
|
$queryRawUnsafe: {
|
|
args: [query: string, ...values: any[]],
|
|
result: any
|
|
}
|
|
}
|
|
}
|
|
}
|
|
export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
|
|
export type DefaultPrismaClient = PrismaClient
|
|
export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
|
|
export interface PrismaClientOptions {
|
|
/**
|
|
* Overwrites the datasource url from your schema.prisma file
|
|
*/
|
|
datasources?: Datasources
|
|
/**
|
|
* Overwrites the datasource url from your schema.prisma file
|
|
*/
|
|
datasourceUrl?: string
|
|
/**
|
|
* @default "colorless"
|
|
*/
|
|
errorFormat?: ErrorFormat
|
|
/**
|
|
* @example
|
|
* ```
|
|
* // 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://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
|
|
*/
|
|
log?: (LogLevel | LogDefinition)[]
|
|
/**
|
|
* The default values for transactionOptions
|
|
* maxWait ?= 2000
|
|
* timeout ?= 5000
|
|
*/
|
|
transactionOptions?: {
|
|
maxWait?: number
|
|
timeout?: number
|
|
isolationLevel?: Prisma.TransactionIsolationLevel
|
|
}
|
|
/**
|
|
* Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`
|
|
*/
|
|
adapter?: runtime.SqlDriverAdapterFactory | null
|
|
/**
|
|
* Global configuration for omitting model fields by default.
|
|
*
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient({
|
|
* omit: {
|
|
* user: {
|
|
* password: true
|
|
* }
|
|
* }
|
|
* })
|
|
* ```
|
|
*/
|
|
omit?: Prisma.GlobalOmitConfig
|
|
}
|
|
export type GlobalOmitConfig = {
|
|
user?: UserOmit
|
|
account?: AccountOmit
|
|
session?: SessionOmit
|
|
verificationToken?: VerificationTokenOmit
|
|
course?: CourseOmit
|
|
module?: ModuleOmit
|
|
lesson?: LessonOmit
|
|
quiz?: QuizOmit
|
|
question?: QuestionOmit
|
|
enrollment?: EnrollmentOmit
|
|
lessonProgress?: LessonProgressOmit
|
|
quizAttempt?: QuizAttemptOmit
|
|
certificate?: CertificateOmit
|
|
}
|
|
|
|
/* 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 UserCountOutputType
|
|
*/
|
|
|
|
export type UserCountOutputType = {
|
|
accounts: number
|
|
sessions: number
|
|
enrollments: number
|
|
lessonProgress: number
|
|
quizAttempts: number
|
|
certificates: number
|
|
}
|
|
|
|
export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
accounts?: boolean | UserCountOutputTypeCountAccountsArgs
|
|
sessions?: boolean | UserCountOutputTypeCountSessionsArgs
|
|
enrollments?: boolean | UserCountOutputTypeCountEnrollmentsArgs
|
|
lessonProgress?: boolean | UserCountOutputTypeCountLessonProgressArgs
|
|
quizAttempts?: boolean | UserCountOutputTypeCountQuizAttemptsArgs
|
|
certificates?: boolean | UserCountOutputTypeCountCertificatesArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCountOutputType
|
|
*/
|
|
select?: UserCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountAccountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AccountWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountSessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SessionWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountEnrollmentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: EnrollmentWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountLessonProgressArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: LessonProgressWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountQuizAttemptsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: QuizAttemptWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountCertificatesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: CertificateWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type CourseCountOutputType
|
|
*/
|
|
|
|
export type CourseCountOutputType = {
|
|
modules: number
|
|
enrollments: number
|
|
certificates: number
|
|
}
|
|
|
|
export type CourseCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
modules?: boolean | CourseCountOutputTypeCountModulesArgs
|
|
enrollments?: boolean | CourseCountOutputTypeCountEnrollmentsArgs
|
|
certificates?: boolean | CourseCountOutputTypeCountCertificatesArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* CourseCountOutputType without action
|
|
*/
|
|
export type CourseCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the CourseCountOutputType
|
|
*/
|
|
select?: CourseCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* CourseCountOutputType without action
|
|
*/
|
|
export type CourseCountOutputTypeCountModulesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ModuleWhereInput
|
|
}
|
|
|
|
/**
|
|
* CourseCountOutputType without action
|
|
*/
|
|
export type CourseCountOutputTypeCountEnrollmentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: EnrollmentWhereInput
|
|
}
|
|
|
|
/**
|
|
* CourseCountOutputType without action
|
|
*/
|
|
export type CourseCountOutputTypeCountCertificatesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: CertificateWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type ModuleCountOutputType
|
|
*/
|
|
|
|
export type ModuleCountOutputType = {
|
|
lessons: number
|
|
}
|
|
|
|
export type ModuleCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
lessons?: boolean | ModuleCountOutputTypeCountLessonsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* ModuleCountOutputType without action
|
|
*/
|
|
export type ModuleCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ModuleCountOutputType
|
|
*/
|
|
select?: ModuleCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* ModuleCountOutputType without action
|
|
*/
|
|
export type ModuleCountOutputTypeCountLessonsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: LessonWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type LessonCountOutputType
|
|
*/
|
|
|
|
export type LessonCountOutputType = {
|
|
lessonProgress: number
|
|
}
|
|
|
|
export type LessonCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
lessonProgress?: boolean | LessonCountOutputTypeCountLessonProgressArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* LessonCountOutputType without action
|
|
*/
|
|
export type LessonCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonCountOutputType
|
|
*/
|
|
select?: LessonCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* LessonCountOutputType without action
|
|
*/
|
|
export type LessonCountOutputTypeCountLessonProgressArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: LessonProgressWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type QuizCountOutputType
|
|
*/
|
|
|
|
export type QuizCountOutputType = {
|
|
questions: number
|
|
attempts: number
|
|
}
|
|
|
|
export type QuizCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
questions?: boolean | QuizCountOutputTypeCountQuestionsArgs
|
|
attempts?: boolean | QuizCountOutputTypeCountAttemptsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* QuizCountOutputType without action
|
|
*/
|
|
export type QuizCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizCountOutputType
|
|
*/
|
|
select?: QuizCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* QuizCountOutputType without action
|
|
*/
|
|
export type QuizCountOutputTypeCountQuestionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: QuestionWhereInput
|
|
}
|
|
|
|
/**
|
|
* QuizCountOutputType without action
|
|
*/
|
|
export type QuizCountOutputTypeCountAttemptsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: QuizAttemptWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Models
|
|
*/
|
|
|
|
/**
|
|
* Model User
|
|
*/
|
|
|
|
export type AggregateUser = {
|
|
_count: UserCountAggregateOutputType | null
|
|
_min: UserMinAggregateOutputType | null
|
|
_max: UserMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type UserMinAggregateOutputType = {
|
|
id: string | null
|
|
email: string | null
|
|
name: string | null
|
|
image: string | null
|
|
emailVerified: Date | null
|
|
locale: string | null
|
|
role: $Enums.Role | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type UserMaxAggregateOutputType = {
|
|
id: string | null
|
|
email: string | null
|
|
name: string | null
|
|
image: string | null
|
|
emailVerified: Date | null
|
|
locale: string | null
|
|
role: $Enums.Role | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type UserCountAggregateOutputType = {
|
|
id: number
|
|
email: number
|
|
name: number
|
|
image: number
|
|
emailVerified: number
|
|
locale: number
|
|
role: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type UserMinAggregateInputType = {
|
|
id?: true
|
|
email?: true
|
|
name?: true
|
|
image?: true
|
|
emailVerified?: true
|
|
locale?: true
|
|
role?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type UserMaxAggregateInputType = {
|
|
id?: true
|
|
email?: true
|
|
name?: true
|
|
image?: true
|
|
emailVerified?: true
|
|
locale?: true
|
|
role?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type UserCountAggregateInputType = {
|
|
id?: true
|
|
email?: true
|
|
name?: true
|
|
image?: true
|
|
emailVerified?: true
|
|
locale?: true
|
|
role?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which User to aggregate.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Users
|
|
**/
|
|
_count?: true | UserCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: UserMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: UserMaxAggregateInputType
|
|
}
|
|
|
|
export type GetUserAggregateType<T extends UserAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateUser]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateUser[P]>
|
|
: GetScalarType<T[P], AggregateUser[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserWhereInput
|
|
orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
|
|
by: UserScalarFieldEnum[] | UserScalarFieldEnum
|
|
having?: UserScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: UserCountAggregateInputType | true
|
|
_min?: UserMinAggregateInputType
|
|
_max?: UserMaxAggregateInputType
|
|
}
|
|
|
|
export type UserGroupByOutputType = {
|
|
id: string
|
|
email: string
|
|
name: string | null
|
|
image: string | null
|
|
emailVerified: Date | null
|
|
locale: string
|
|
role: $Enums.Role
|
|
createdAt: Date
|
|
_count: UserCountAggregateOutputType | null
|
|
_min: UserMinAggregateOutputType | null
|
|
_max: UserMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<UserGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], UserGroupByOutputType[P]>
|
|
: GetScalarType<T[P], UserGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
email?: boolean
|
|
name?: boolean
|
|
image?: boolean
|
|
emailVerified?: boolean
|
|
locale?: boolean
|
|
role?: boolean
|
|
createdAt?: boolean
|
|
accounts?: boolean | User$accountsArgs<ExtArgs>
|
|
sessions?: boolean | User$sessionsArgs<ExtArgs>
|
|
enrollments?: boolean | User$enrollmentsArgs<ExtArgs>
|
|
lessonProgress?: boolean | User$lessonProgressArgs<ExtArgs>
|
|
quizAttempts?: boolean | User$quizAttemptsArgs<ExtArgs>
|
|
certificates?: boolean | User$certificatesArgs<ExtArgs>
|
|
_count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["user"]>
|
|
|
|
export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
email?: boolean
|
|
name?: boolean
|
|
image?: boolean
|
|
emailVerified?: boolean
|
|
locale?: boolean
|
|
role?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["user"]>
|
|
|
|
export type UserSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
email?: boolean
|
|
name?: boolean
|
|
image?: boolean
|
|
emailVerified?: boolean
|
|
locale?: boolean
|
|
role?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["user"]>
|
|
|
|
export type UserSelectScalar = {
|
|
id?: boolean
|
|
email?: boolean
|
|
name?: boolean
|
|
image?: boolean
|
|
emailVerified?: boolean
|
|
locale?: boolean
|
|
role?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "email" | "name" | "image" | "emailVerified" | "locale" | "role" | "createdAt", ExtArgs["result"]["user"]>
|
|
export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
accounts?: boolean | User$accountsArgs<ExtArgs>
|
|
sessions?: boolean | User$sessionsArgs<ExtArgs>
|
|
enrollments?: boolean | User$enrollmentsArgs<ExtArgs>
|
|
lessonProgress?: boolean | User$lessonProgressArgs<ExtArgs>
|
|
quizAttempts?: boolean | User$quizAttemptsArgs<ExtArgs>
|
|
certificates?: boolean | User$certificatesArgs<ExtArgs>
|
|
_count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
export type UserIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "User"
|
|
objects: {
|
|
accounts: Prisma.$AccountPayload<ExtArgs>[]
|
|
sessions: Prisma.$SessionPayload<ExtArgs>[]
|
|
enrollments: Prisma.$EnrollmentPayload<ExtArgs>[]
|
|
lessonProgress: Prisma.$LessonProgressPayload<ExtArgs>[]
|
|
quizAttempts: Prisma.$QuizAttemptPayload<ExtArgs>[]
|
|
certificates: Prisma.$CertificatePayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
email: string
|
|
name: string | null
|
|
image: string | null
|
|
emailVerified: Date | null
|
|
locale: string
|
|
role: $Enums.Role
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["user"]>
|
|
composites: {}
|
|
}
|
|
|
|
type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>
|
|
|
|
type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: UserCountAggregateInputType | true
|
|
}
|
|
|
|
export interface UserDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } }
|
|
/**
|
|
* Find zero or one User that matches the filter.
|
|
* @param {UserFindUniqueArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends UserFindUniqueArgs>(args: SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one User that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first User that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserFindFirstArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends UserFindFirstArgs>(args?: SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first User that matches the filter or
|
|
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Users that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Users
|
|
* const users = await prisma.user.findMany()
|
|
*
|
|
* // Get first 10 Users
|
|
* const users = await prisma.user.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const userWithIdOnly = await prisma.user.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends UserFindManyArgs>(args?: SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a User.
|
|
* @param {UserCreateArgs} args - Arguments to create a User.
|
|
* @example
|
|
* // Create one User
|
|
* const User = await prisma.user.create({
|
|
* data: {
|
|
* // ... data to create a User
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Users.
|
|
* @param {UserCreateManyArgs} args - Arguments to create many Users.
|
|
* @example
|
|
* // Create many Users
|
|
* const user = await prisma.user.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends UserCreateManyArgs>(args?: SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Users and returns the data saved in the database.
|
|
* @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
|
|
* @example
|
|
* // Create many Users
|
|
* const user = await prisma.user.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Users and only return the `id`
|
|
* const userWithIdOnly = await prisma.user.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a User.
|
|
* @param {UserDeleteArgs} args - Arguments to delete one User.
|
|
* @example
|
|
* // Delete one User
|
|
* const User = await prisma.user.delete({
|
|
* where: {
|
|
* // ... filter to delete one User
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one User.
|
|
* @param {UserUpdateArgs} args - Arguments to update one User.
|
|
* @example
|
|
* // Update one User
|
|
* const user = await prisma.user.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends UserUpdateArgs>(args: SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Users.
|
|
* @param {UserDeleteManyArgs} args - Arguments to filter Users to delete.
|
|
* @example
|
|
* // Delete a few Users
|
|
* const { count } = await prisma.user.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends UserDeleteManyArgs>(args?: SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Users.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Users
|
|
* const user = await prisma.user.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends UserUpdateManyArgs>(args: SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Users and returns the data updated in the database.
|
|
* @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users.
|
|
* @example
|
|
* // Update many Users
|
|
* const user = await prisma.user.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Users and only return the `id`
|
|
* const userWithIdOnly = await prisma.user.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one User.
|
|
* @param {UserUpsertArgs} args - Arguments to update or create a User.
|
|
* @example
|
|
* // Update or create a User
|
|
* const user = await prisma.user.upsert({
|
|
* create: {
|
|
* // ... data to create a User
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the User we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends UserUpsertArgs>(args: SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Users.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserCountArgs} args - Arguments to filter Users to count.
|
|
* @example
|
|
* // Count the number of Users
|
|
* const count = await prisma.user.count({
|
|
* where: {
|
|
* // ... the filter for the Users we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends UserCountArgs>(
|
|
args?: Subset<T, UserCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], UserCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a User.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>
|
|
|
|
/**
|
|
* Group by User.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserGroupByArgs} args - Group by arguments.
|
|
* @example
|
|
* // Group by city, order by createdAt, get count
|
|
* const result = await prisma.user.groupBy({
|
|
* by: ['city', 'createdAt'],
|
|
* orderBy: {
|
|
* createdAt: true
|
|
* },
|
|
* _count: {
|
|
* _all: true
|
|
* },
|
|
* })
|
|
*
|
|
**/
|
|
groupBy<
|
|
T extends UserGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: UserGroupByArgs['orderBy'] }
|
|
: { orderBy?: UserGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the User model
|
|
*/
|
|
readonly fields: UserFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for User.
|
|
* Why is this prefixed with `Prisma__`?
|
|
* Because we want to prevent naming conflicts as mentioned in
|
|
* https://github.com/prisma/prisma-client-js/issues/707
|
|
*/
|
|
export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
accounts<T extends User$accountsArgs<ExtArgs> = {}>(args?: Subset<T, User$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
sessions<T extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
enrollments<T extends User$enrollmentsArgs<ExtArgs> = {}>(args?: Subset<T, User$enrollmentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
lessonProgress<T extends User$lessonProgressArgs<ExtArgs> = {}>(args?: Subset<T, User$lessonProgressArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
quizAttempts<T extends User$quizAttemptsArgs<ExtArgs> = {}>(args?: Subset<T, User$quizAttemptsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
certificates<T extends User$certificatesArgs<ExtArgs> = {}>(args?: Subset<T, User$certificatesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the User model
|
|
*/
|
|
interface UserFieldRefs {
|
|
readonly id: FieldRef<"User", 'String'>
|
|
readonly email: FieldRef<"User", 'String'>
|
|
readonly name: FieldRef<"User", 'String'>
|
|
readonly image: FieldRef<"User", 'String'>
|
|
readonly emailVerified: FieldRef<"User", 'DateTime'>
|
|
readonly locale: FieldRef<"User", 'String'>
|
|
readonly role: FieldRef<"User", 'Role'>
|
|
readonly createdAt: FieldRef<"User", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* User findUnique
|
|
*/
|
|
export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User findUniqueOrThrow
|
|
*/
|
|
export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User findFirst
|
|
*/
|
|
export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Users.
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Users.
|
|
*/
|
|
distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User findFirstOrThrow
|
|
*/
|
|
export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Users.
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Users.
|
|
*/
|
|
distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User findMany
|
|
*/
|
|
export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Users to fetch.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Users.
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User create
|
|
*/
|
|
export type UserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a User.
|
|
*/
|
|
data: XOR<UserCreateInput, UserUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* User createMany
|
|
*/
|
|
export type UserCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Users.
|
|
*/
|
|
data: UserCreateManyInput | UserCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* User createManyAndReturn
|
|
*/
|
|
export type UserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Users.
|
|
*/
|
|
data: UserCreateManyInput | UserCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* User update
|
|
*/
|
|
export type UserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a User.
|
|
*/
|
|
data: XOR<UserUpdateInput, UserUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which User to update.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User updateMany
|
|
*/
|
|
export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Users.
|
|
*/
|
|
data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Users to update
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* Limit how many Users to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* User updateManyAndReturn
|
|
*/
|
|
export type UserUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Users.
|
|
*/
|
|
data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Users to update
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* Limit how many Users to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* User upsert
|
|
*/
|
|
export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the User to update in case it exists.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
/**
|
|
* In case the User found by the `where` argument doesn't exist, create a new User with this data.
|
|
*/
|
|
create: XOR<UserCreateInput, UserUncheckedCreateInput>
|
|
/**
|
|
* In case the User was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* User delete
|
|
*/
|
|
export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which User to delete.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User deleteMany
|
|
*/
|
|
export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Users to delete
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* Limit how many Users to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* User.accounts
|
|
*/
|
|
export type User$accountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
where?: AccountWhereInput
|
|
orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
|
|
cursor?: AccountWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.sessions
|
|
*/
|
|
export type User$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
where?: SessionWhereInput
|
|
orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
|
|
cursor?: SessionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.enrollments
|
|
*/
|
|
export type User$enrollmentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
where?: EnrollmentWhereInput
|
|
orderBy?: EnrollmentOrderByWithRelationInput | EnrollmentOrderByWithRelationInput[]
|
|
cursor?: EnrollmentWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: EnrollmentScalarFieldEnum | EnrollmentScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.lessonProgress
|
|
*/
|
|
export type User$lessonProgressArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
where?: LessonProgressWhereInput
|
|
orderBy?: LessonProgressOrderByWithRelationInput | LessonProgressOrderByWithRelationInput[]
|
|
cursor?: LessonProgressWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: LessonProgressScalarFieldEnum | LessonProgressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.quizAttempts
|
|
*/
|
|
export type User$quizAttemptsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
where?: QuizAttemptWhereInput
|
|
orderBy?: QuizAttemptOrderByWithRelationInput | QuizAttemptOrderByWithRelationInput[]
|
|
cursor?: QuizAttemptWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: QuizAttemptScalarFieldEnum | QuizAttemptScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.certificates
|
|
*/
|
|
export type User$certificatesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
where?: CertificateWhereInput
|
|
orderBy?: CertificateOrderByWithRelationInput | CertificateOrderByWithRelationInput[]
|
|
cursor?: CertificateWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: CertificateScalarFieldEnum | CertificateScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User without action
|
|
*/
|
|
export type UserDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the User
|
|
*/
|
|
omit?: UserOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Account
|
|
*/
|
|
|
|
export type AggregateAccount = {
|
|
_count: AccountCountAggregateOutputType | null
|
|
_avg: AccountAvgAggregateOutputType | null
|
|
_sum: AccountSumAggregateOutputType | null
|
|
_min: AccountMinAggregateOutputType | null
|
|
_max: AccountMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type AccountAvgAggregateOutputType = {
|
|
expires_at: number | null
|
|
}
|
|
|
|
export type AccountSumAggregateOutputType = {
|
|
expires_at: number | null
|
|
}
|
|
|
|
export type AccountMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
type: string | null
|
|
provider: string | null
|
|
providerAccountId: string | null
|
|
refresh_token: string | null
|
|
access_token: string | null
|
|
expires_at: number | null
|
|
token_type: string | null
|
|
scope: string | null
|
|
id_token: string | null
|
|
session_state: string | null
|
|
}
|
|
|
|
export type AccountMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
type: string | null
|
|
provider: string | null
|
|
providerAccountId: string | null
|
|
refresh_token: string | null
|
|
access_token: string | null
|
|
expires_at: number | null
|
|
token_type: string | null
|
|
scope: string | null
|
|
id_token: string | null
|
|
session_state: string | null
|
|
}
|
|
|
|
export type AccountCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
type: number
|
|
provider: number
|
|
providerAccountId: number
|
|
refresh_token: number
|
|
access_token: number
|
|
expires_at: number
|
|
token_type: number
|
|
scope: number
|
|
id_token: number
|
|
session_state: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type AccountAvgAggregateInputType = {
|
|
expires_at?: true
|
|
}
|
|
|
|
export type AccountSumAggregateInputType = {
|
|
expires_at?: true
|
|
}
|
|
|
|
export type AccountMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
type?: true
|
|
provider?: true
|
|
providerAccountId?: true
|
|
refresh_token?: true
|
|
access_token?: true
|
|
expires_at?: true
|
|
token_type?: true
|
|
scope?: true
|
|
id_token?: true
|
|
session_state?: true
|
|
}
|
|
|
|
export type AccountMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
type?: true
|
|
provider?: true
|
|
providerAccountId?: true
|
|
refresh_token?: true
|
|
access_token?: true
|
|
expires_at?: true
|
|
token_type?: true
|
|
scope?: true
|
|
id_token?: true
|
|
session_state?: true
|
|
}
|
|
|
|
export type AccountCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
type?: true
|
|
provider?: true
|
|
providerAccountId?: true
|
|
refresh_token?: true
|
|
access_token?: true
|
|
expires_at?: true
|
|
token_type?: true
|
|
scope?: true
|
|
id_token?: true
|
|
session_state?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type AccountAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Account to aggregate.
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Accounts to fetch.
|
|
*/
|
|
orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: AccountWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Accounts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Accounts.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Accounts
|
|
**/
|
|
_count?: true | AccountCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: AccountAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: AccountSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: AccountMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: AccountMaxAggregateInputType
|
|
}
|
|
|
|
export type GetAccountAggregateType<T extends AccountAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateAccount]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateAccount[P]>
|
|
: GetScalarType<T[P], AggregateAccount[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type AccountGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AccountWhereInput
|
|
orderBy?: AccountOrderByWithAggregationInput | AccountOrderByWithAggregationInput[]
|
|
by: AccountScalarFieldEnum[] | AccountScalarFieldEnum
|
|
having?: AccountScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: AccountCountAggregateInputType | true
|
|
_avg?: AccountAvgAggregateInputType
|
|
_sum?: AccountSumAggregateInputType
|
|
_min?: AccountMinAggregateInputType
|
|
_max?: AccountMaxAggregateInputType
|
|
}
|
|
|
|
export type AccountGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token: string | null
|
|
access_token: string | null
|
|
expires_at: number | null
|
|
token_type: string | null
|
|
scope: string | null
|
|
id_token: string | null
|
|
session_state: string | null
|
|
_count: AccountCountAggregateOutputType | null
|
|
_avg: AccountAvgAggregateOutputType | null
|
|
_sum: AccountSumAggregateOutputType | null
|
|
_min: AccountMinAggregateOutputType | null
|
|
_max: AccountMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetAccountGroupByPayload<T extends AccountGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<AccountGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof AccountGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], AccountGroupByOutputType[P]>
|
|
: GetScalarType<T[P], AccountGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type AccountSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
type?: boolean
|
|
provider?: boolean
|
|
providerAccountId?: boolean
|
|
refresh_token?: boolean
|
|
access_token?: boolean
|
|
expires_at?: boolean
|
|
token_type?: boolean
|
|
scope?: boolean
|
|
id_token?: boolean
|
|
session_state?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["account"]>
|
|
|
|
export type AccountSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
type?: boolean
|
|
provider?: boolean
|
|
providerAccountId?: boolean
|
|
refresh_token?: boolean
|
|
access_token?: boolean
|
|
expires_at?: boolean
|
|
token_type?: boolean
|
|
scope?: boolean
|
|
id_token?: boolean
|
|
session_state?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["account"]>
|
|
|
|
export type AccountSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
type?: boolean
|
|
provider?: boolean
|
|
providerAccountId?: boolean
|
|
refresh_token?: boolean
|
|
access_token?: boolean
|
|
expires_at?: boolean
|
|
token_type?: boolean
|
|
scope?: boolean
|
|
id_token?: boolean
|
|
session_state?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["account"]>
|
|
|
|
export type AccountSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
type?: boolean
|
|
provider?: boolean
|
|
providerAccountId?: boolean
|
|
refresh_token?: boolean
|
|
access_token?: boolean
|
|
expires_at?: boolean
|
|
token_type?: boolean
|
|
scope?: boolean
|
|
id_token?: boolean
|
|
session_state?: boolean
|
|
}
|
|
|
|
export type AccountOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "type" | "provider" | "providerAccountId" | "refresh_token" | "access_token" | "expires_at" | "token_type" | "scope" | "id_token" | "session_state", ExtArgs["result"]["account"]>
|
|
export type AccountInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}
|
|
export type AccountIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}
|
|
export type AccountIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $AccountPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Account"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token: string | null
|
|
access_token: string | null
|
|
expires_at: number | null
|
|
token_type: string | null
|
|
scope: string | null
|
|
id_token: string | null
|
|
session_state: string | null
|
|
}, ExtArgs["result"]["account"]>
|
|
composites: {}
|
|
}
|
|
|
|
type AccountGetPayload<S extends boolean | null | undefined | AccountDefaultArgs> = $Result.GetResult<Prisma.$AccountPayload, S>
|
|
|
|
type AccountCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<AccountFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: AccountCountAggregateInputType | true
|
|
}
|
|
|
|
export interface AccountDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Account'], meta: { name: 'Account' } }
|
|
/**
|
|
* Find zero or one Account that matches the filter.
|
|
* @param {AccountFindUniqueArgs} args - Arguments to find a Account
|
|
* @example
|
|
* // Get one Account
|
|
* const account = await prisma.account.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends AccountFindUniqueArgs>(args: SelectSubset<T, AccountFindUniqueArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Account that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {AccountFindUniqueOrThrowArgs} args - Arguments to find a Account
|
|
* @example
|
|
* // Get one Account
|
|
* const account = await prisma.account.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends AccountFindUniqueOrThrowArgs>(args: SelectSubset<T, AccountFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Account that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountFindFirstArgs} args - Arguments to find a Account
|
|
* @example
|
|
* // Get one Account
|
|
* const account = await prisma.account.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends AccountFindFirstArgs>(args?: SelectSubset<T, AccountFindFirstArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Account that matches the filter or
|
|
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountFindFirstOrThrowArgs} args - Arguments to find a Account
|
|
* @example
|
|
* // Get one Account
|
|
* const account = await prisma.account.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends AccountFindFirstOrThrowArgs>(args?: SelectSubset<T, AccountFindFirstOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Accounts that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Accounts
|
|
* const accounts = await prisma.account.findMany()
|
|
*
|
|
* // Get first 10 Accounts
|
|
* const accounts = await prisma.account.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const accountWithIdOnly = await prisma.account.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends AccountFindManyArgs>(args?: SelectSubset<T, AccountFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Account.
|
|
* @param {AccountCreateArgs} args - Arguments to create a Account.
|
|
* @example
|
|
* // Create one Account
|
|
* const Account = await prisma.account.create({
|
|
* data: {
|
|
* // ... data to create a Account
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends AccountCreateArgs>(args: SelectSubset<T, AccountCreateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Accounts.
|
|
* @param {AccountCreateManyArgs} args - Arguments to create many Accounts.
|
|
* @example
|
|
* // Create many Accounts
|
|
* const account = await prisma.account.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends AccountCreateManyArgs>(args?: SelectSubset<T, AccountCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Accounts and returns the data saved in the database.
|
|
* @param {AccountCreateManyAndReturnArgs} args - Arguments to create many Accounts.
|
|
* @example
|
|
* // Create many Accounts
|
|
* const account = await prisma.account.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Accounts and only return the `id`
|
|
* const accountWithIdOnly = await prisma.account.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends AccountCreateManyAndReturnArgs>(args?: SelectSubset<T, AccountCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Account.
|
|
* @param {AccountDeleteArgs} args - Arguments to delete one Account.
|
|
* @example
|
|
* // Delete one Account
|
|
* const Account = await prisma.account.delete({
|
|
* where: {
|
|
* // ... filter to delete one Account
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends AccountDeleteArgs>(args: SelectSubset<T, AccountDeleteArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Account.
|
|
* @param {AccountUpdateArgs} args - Arguments to update one Account.
|
|
* @example
|
|
* // Update one Account
|
|
* const account = await prisma.account.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends AccountUpdateArgs>(args: SelectSubset<T, AccountUpdateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Accounts.
|
|
* @param {AccountDeleteManyArgs} args - Arguments to filter Accounts to delete.
|
|
* @example
|
|
* // Delete a few Accounts
|
|
* const { count } = await prisma.account.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends AccountDeleteManyArgs>(args?: SelectSubset<T, AccountDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Accounts.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Accounts
|
|
* const account = await prisma.account.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends AccountUpdateManyArgs>(args: SelectSubset<T, AccountUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Accounts and returns the data updated in the database.
|
|
* @param {AccountUpdateManyAndReturnArgs} args - Arguments to update many Accounts.
|
|
* @example
|
|
* // Update many Accounts
|
|
* const account = await prisma.account.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Accounts and only return the `id`
|
|
* const accountWithIdOnly = await prisma.account.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends AccountUpdateManyAndReturnArgs>(args: SelectSubset<T, AccountUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Account.
|
|
* @param {AccountUpsertArgs} args - Arguments to update or create a Account.
|
|
* @example
|
|
* // Update or create a Account
|
|
* const account = await prisma.account.upsert({
|
|
* create: {
|
|
* // ... data to create a Account
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Account we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends AccountUpsertArgs>(args: SelectSubset<T, AccountUpsertArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Accounts.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountCountArgs} args - Arguments to filter Accounts to count.
|
|
* @example
|
|
* // Count the number of Accounts
|
|
* const count = await prisma.account.count({
|
|
* where: {
|
|
* // ... the filter for the Accounts we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends AccountCountArgs>(
|
|
args?: Subset<T, AccountCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], AccountCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Account.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends AccountAggregateArgs>(args: Subset<T, AccountAggregateArgs>): Prisma.PrismaPromise<GetAccountAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Account.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AccountGroupByArgs} args - Group by arguments.
|
|
* @example
|
|
* // Group by city, order by createdAt, get count
|
|
* const result = await prisma.user.groupBy({
|
|
* by: ['city', 'createdAt'],
|
|
* orderBy: {
|
|
* createdAt: true
|
|
* },
|
|
* _count: {
|
|
* _all: true
|
|
* },
|
|
* })
|
|
*
|
|
**/
|
|
groupBy<
|
|
T extends AccountGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: AccountGroupByArgs['orderBy'] }
|
|
: { orderBy?: AccountGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, AccountGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccountGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Account model
|
|
*/
|
|
readonly fields: AccountFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Account.
|
|
* Why is this prefixed with `Prisma__`?
|
|
* Because we want to prevent naming conflicts as mentioned in
|
|
* https://github.com/prisma/prisma-client-js/issues/707
|
|
*/
|
|
export interface Prisma__AccountClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the Account model
|
|
*/
|
|
interface AccountFieldRefs {
|
|
readonly id: FieldRef<"Account", 'String'>
|
|
readonly userId: FieldRef<"Account", 'String'>
|
|
readonly type: FieldRef<"Account", 'String'>
|
|
readonly provider: FieldRef<"Account", 'String'>
|
|
readonly providerAccountId: FieldRef<"Account", 'String'>
|
|
readonly refresh_token: FieldRef<"Account", 'String'>
|
|
readonly access_token: FieldRef<"Account", 'String'>
|
|
readonly expires_at: FieldRef<"Account", 'Int'>
|
|
readonly token_type: FieldRef<"Account", 'String'>
|
|
readonly scope: FieldRef<"Account", 'String'>
|
|
readonly id_token: FieldRef<"Account", 'String'>
|
|
readonly session_state: FieldRef<"Account", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Account findUnique
|
|
*/
|
|
export type AccountFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Account to fetch.
|
|
*/
|
|
where: AccountWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Account findUniqueOrThrow
|
|
*/
|
|
export type AccountFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Account to fetch.
|
|
*/
|
|
where: AccountWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Account findFirst
|
|
*/
|
|
export type AccountFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Account to fetch.
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Accounts to fetch.
|
|
*/
|
|
orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Accounts.
|
|
*/
|
|
cursor?: AccountWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Accounts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Accounts.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Accounts.
|
|
*/
|
|
distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Account findFirstOrThrow
|
|
*/
|
|
export type AccountFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Account to fetch.
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Accounts to fetch.
|
|
*/
|
|
orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Accounts.
|
|
*/
|
|
cursor?: AccountWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Accounts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Accounts.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Accounts.
|
|
*/
|
|
distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Account findMany
|
|
*/
|
|
export type AccountFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Accounts to fetch.
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Accounts to fetch.
|
|
*/
|
|
orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Accounts.
|
|
*/
|
|
cursor?: AccountWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Accounts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Accounts.
|
|
*/
|
|
skip?: number
|
|
distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Account create
|
|
*/
|
|
export type AccountCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Account.
|
|
*/
|
|
data: XOR<AccountCreateInput, AccountUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Account createMany
|
|
*/
|
|
export type AccountCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Accounts.
|
|
*/
|
|
data: AccountCreateManyInput | AccountCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Account createManyAndReturn
|
|
*/
|
|
export type AccountCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Accounts.
|
|
*/
|
|
data: AccountCreateManyInput | AccountCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Account update
|
|
*/
|
|
export type AccountUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Account.
|
|
*/
|
|
data: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Account to update.
|
|
*/
|
|
where: AccountWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Account updateMany
|
|
*/
|
|
export type AccountUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Accounts.
|
|
*/
|
|
data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Accounts to update
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* Limit how many Accounts to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Account updateManyAndReturn
|
|
*/
|
|
export type AccountUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Accounts.
|
|
*/
|
|
data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Accounts to update
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* Limit how many Accounts to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Account upsert
|
|
*/
|
|
export type AccountUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Account to update in case it exists.
|
|
*/
|
|
where: AccountWhereUniqueInput
|
|
/**
|
|
* In case the Account found by the `where` argument doesn't exist, create a new Account with this data.
|
|
*/
|
|
create: XOR<AccountCreateInput, AccountUncheckedCreateInput>
|
|
/**
|
|
* In case the Account was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Account delete
|
|
*/
|
|
export type AccountDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Account to delete.
|
|
*/
|
|
where: AccountWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Account deleteMany
|
|
*/
|
|
export type AccountDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Accounts to delete
|
|
*/
|
|
where?: AccountWhereInput
|
|
/**
|
|
* Limit how many Accounts to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Account without action
|
|
*/
|
|
export type AccountDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Account
|
|
*/
|
|
select?: AccountSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Account
|
|
*/
|
|
omit?: AccountOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AccountInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Session
|
|
*/
|
|
|
|
export type AggregateSession = {
|
|
_count: SessionCountAggregateOutputType | null
|
|
_min: SessionMinAggregateOutputType | null
|
|
_max: SessionMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type SessionMinAggregateOutputType = {
|
|
id: string | null
|
|
sessionToken: string | null
|
|
userId: string | null
|
|
expires: Date | null
|
|
}
|
|
|
|
export type SessionMaxAggregateOutputType = {
|
|
id: string | null
|
|
sessionToken: string | null
|
|
userId: string | null
|
|
expires: Date | null
|
|
}
|
|
|
|
export type SessionCountAggregateOutputType = {
|
|
id: number
|
|
sessionToken: number
|
|
userId: number
|
|
expires: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type SessionMinAggregateInputType = {
|
|
id?: true
|
|
sessionToken?: true
|
|
userId?: true
|
|
expires?: true
|
|
}
|
|
|
|
export type SessionMaxAggregateInputType = {
|
|
id?: true
|
|
sessionToken?: true
|
|
userId?: true
|
|
expires?: true
|
|
}
|
|
|
|
export type SessionCountAggregateInputType = {
|
|
id?: true
|
|
sessionToken?: true
|
|
userId?: true
|
|
expires?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type SessionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Session to aggregate.
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Sessions to fetch.
|
|
*/
|
|
orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: SessionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Sessions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Sessions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Sessions
|
|
**/
|
|
_count?: true | SessionCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: SessionMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: SessionMaxAggregateInputType
|
|
}
|
|
|
|
export type GetSessionAggregateType<T extends SessionAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateSession]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateSession[P]>
|
|
: GetScalarType<T[P], AggregateSession[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type SessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SessionWhereInput
|
|
orderBy?: SessionOrderByWithAggregationInput | SessionOrderByWithAggregationInput[]
|
|
by: SessionScalarFieldEnum[] | SessionScalarFieldEnum
|
|
having?: SessionScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: SessionCountAggregateInputType | true
|
|
_min?: SessionMinAggregateInputType
|
|
_max?: SessionMaxAggregateInputType
|
|
}
|
|
|
|
export type SessionGroupByOutputType = {
|
|
id: string
|
|
sessionToken: string
|
|
userId: string
|
|
expires: Date
|
|
_count: SessionCountAggregateOutputType | null
|
|
_min: SessionMinAggregateOutputType | null
|
|
_max: SessionMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetSessionGroupByPayload<T extends SessionGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<SessionGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof SessionGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], SessionGroupByOutputType[P]>
|
|
: GetScalarType<T[P], SessionGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type SessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
sessionToken?: boolean
|
|
userId?: boolean
|
|
expires?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["session"]>
|
|
|
|
export type SessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
sessionToken?: boolean
|
|
userId?: boolean
|
|
expires?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["session"]>
|
|
|
|
export type SessionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
sessionToken?: boolean
|
|
userId?: boolean
|
|
expires?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["session"]>
|
|
|
|
export type SessionSelectScalar = {
|
|
id?: boolean
|
|
sessionToken?: boolean
|
|
userId?: boolean
|
|
expires?: boolean
|
|
}
|
|
|
|
export type SessionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "sessionToken" | "userId" | "expires", ExtArgs["result"]["session"]>
|
|
export type SessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}
|
|
export type SessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}
|
|
export type SessionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $SessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Session"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
sessionToken: string
|
|
userId: string
|
|
expires: Date
|
|
}, ExtArgs["result"]["session"]>
|
|
composites: {}
|
|
}
|
|
|
|
type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = $Result.GetResult<Prisma.$SessionPayload, S>
|
|
|
|
type SessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: SessionCountAggregateInputType | true
|
|
}
|
|
|
|
export interface SessionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Session'], meta: { name: 'Session' } }
|
|
/**
|
|
* Find zero or one Session that matches the filter.
|
|
* @param {SessionFindUniqueArgs} args - Arguments to find a Session
|
|
* @example
|
|
* // Get one Session
|
|
* const session = await prisma.session.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends SessionFindUniqueArgs>(args: SelectSubset<T, SessionFindUniqueArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Session that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {SessionFindUniqueOrThrowArgs} args - Arguments to find a Session
|
|
* @example
|
|
* // Get one Session
|
|
* const session = await prisma.session.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends SessionFindUniqueOrThrowArgs>(args: SelectSubset<T, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Session that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionFindFirstArgs} args - Arguments to find a Session
|
|
* @example
|
|
* // Get one Session
|
|
* const session = await prisma.session.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends SessionFindFirstArgs>(args?: SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Session that matches the filter or
|
|
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionFindFirstOrThrowArgs} args - Arguments to find a Session
|
|
* @example
|
|
* // Get one Session
|
|
* const session = await prisma.session.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Sessions that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Sessions
|
|
* const sessions = await prisma.session.findMany()
|
|
*
|
|
* // Get first 10 Sessions
|
|
* const sessions = await prisma.session.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends SessionFindManyArgs>(args?: SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Session.
|
|
* @param {SessionCreateArgs} args - Arguments to create a Session.
|
|
* @example
|
|
* // Create one Session
|
|
* const Session = await prisma.session.create({
|
|
* data: {
|
|
* // ... data to create a Session
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends SessionCreateArgs>(args: SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Sessions.
|
|
* @param {SessionCreateManyArgs} args - Arguments to create many Sessions.
|
|
* @example
|
|
* // Create many Sessions
|
|
* const session = await prisma.session.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends SessionCreateManyArgs>(args?: SelectSubset<T, SessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Sessions and returns the data saved in the database.
|
|
* @param {SessionCreateManyAndReturnArgs} args - Arguments to create many Sessions.
|
|
* @example
|
|
* // Create many Sessions
|
|
* const session = await prisma.session.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Sessions and only return the `id`
|
|
* const sessionWithIdOnly = await prisma.session.createManyAndReturn({
|
|
* select: { id: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends SessionCreateManyAndReturnArgs>(args?: SelectSubset<T, SessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Session.
|
|
* @param {SessionDeleteArgs} args - Arguments to delete one Session.
|
|
* @example
|
|
* // Delete one Session
|
|
* const Session = await prisma.session.delete({
|
|
* where: {
|
|
* // ... filter to delete one Session
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends SessionDeleteArgs>(args: SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Session.
|
|
* @param {SessionUpdateArgs} args - Arguments to update one Session.
|
|
* @example
|
|
* // Update one Session
|
|
* const session = await prisma.session.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends SessionUpdateArgs>(args: SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Sessions.
|
|
* @param {SessionDeleteManyArgs} args - Arguments to filter Sessions to delete.
|
|
* @example
|
|
* // Delete a few Sessions
|
|
* const { count } = await prisma.session.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends SessionDeleteManyArgs>(args?: SelectSubset<T, SessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Sessions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Sessions
|
|
* const session = await prisma.session.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends SessionUpdateManyArgs>(args: SelectSubset<T, SessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Sessions and returns the data updated in the database.
|
|
* @param {SessionUpdateManyAndReturnArgs} args - Arguments to update many Sessions.
|
|
* @example
|
|
* // Update many Sessions
|
|
* const session = await prisma.session.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Sessions and only return the `id`
|
|
* const sessionWithIdOnly = await prisma.session.updateManyAndReturn({
|
|
* select: { id: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends SessionUpdateManyAndReturnArgs>(args: SelectSubset<T, SessionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Session.
|
|
* @param {SessionUpsertArgs} args - Arguments to update or create a Session.
|
|
* @example
|
|
* // Update or create a Session
|
|
* const session = await prisma.session.upsert({
|
|
* create: {
|
|
* // ... data to create a Session
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Session we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends SessionUpsertArgs>(args: SelectSubset<T, SessionUpsertArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Sessions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionCountArgs} args - Arguments to filter Sessions to count.
|
|
* @example
|
|
* // Count the number of Sessions
|
|
* const count = await prisma.session.count({
|
|
* where: {
|
|
* // ... the filter for the Sessions we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends SessionCountArgs>(
|
|
args?: Subset<T, SessionCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], SessionCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Session.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends SessionAggregateArgs>(args: Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Session.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SessionGroupByArgs} args - Group by arguments.
|
|
* @example
|
|
* // Group by city, order by createdAt, get count
|
|
* const result = await prisma.user.groupBy({
|
|
* by: ['city', 'createdAt'],
|
|
* orderBy: {
|
|
* createdAt: true
|
|
* },
|
|
* _count: {
|
|
* _all: true
|
|
* },
|
|
* })
|
|
*
|
|
**/
|
|
groupBy<
|
|
T extends SessionGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: SessionGroupByArgs['orderBy'] }
|
|
: { orderBy?: SessionGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Session model
|
|
*/
|
|
readonly fields: SessionFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Session.
|
|
* Why is this prefixed with `Prisma__`?
|
|
* Because we want to prevent naming conflicts as mentioned in
|
|
* https://github.com/prisma/prisma-client-js/issues/707
|
|
*/
|
|
export interface Prisma__SessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the Session model
|
|
*/
|
|
interface SessionFieldRefs {
|
|
readonly id: FieldRef<"Session", 'String'>
|
|
readonly sessionToken: FieldRef<"Session", 'String'>
|
|
readonly userId: FieldRef<"Session", 'String'>
|
|
readonly expires: FieldRef<"Session", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Session findUnique
|
|
*/
|
|
export type SessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Session to fetch.
|
|
*/
|
|
where: SessionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Session findUniqueOrThrow
|
|
*/
|
|
export type SessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Session to fetch.
|
|
*/
|
|
where: SessionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Session findFirst
|
|
*/
|
|
export type SessionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Session to fetch.
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Sessions to fetch.
|
|
*/
|
|
orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Sessions.
|
|
*/
|
|
cursor?: SessionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Sessions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Sessions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Sessions.
|
|
*/
|
|
distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Session findFirstOrThrow
|
|
*/
|
|
export type SessionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Session to fetch.
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Sessions to fetch.
|
|
*/
|
|
orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Sessions.
|
|
*/
|
|
cursor?: SessionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Sessions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Sessions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Sessions.
|
|
*/
|
|
distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Session findMany
|
|
*/
|
|
export type SessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Sessions to fetch.
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Sessions to fetch.
|
|
*/
|
|
orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Sessions.
|
|
*/
|
|
cursor?: SessionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Sessions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Sessions.
|
|
*/
|
|
skip?: number
|
|
distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Session create
|
|
*/
|
|
export type SessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Session.
|
|
*/
|
|
data: XOR<SessionCreateInput, SessionUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Session createMany
|
|
*/
|
|
export type SessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Sessions.
|
|
*/
|
|
data: SessionCreateManyInput | SessionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Session createManyAndReturn
|
|
*/
|
|
export type SessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Sessions.
|
|
*/
|
|
data: SessionCreateManyInput | SessionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Session update
|
|
*/
|
|
export type SessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Session.
|
|
*/
|
|
data: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Session to update.
|
|
*/
|
|
where: SessionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Session updateMany
|
|
*/
|
|
export type SessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Sessions.
|
|
*/
|
|
data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Sessions to update
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* Limit how many Sessions to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Session updateManyAndReturn
|
|
*/
|
|
export type SessionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Sessions.
|
|
*/
|
|
data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Sessions to update
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* Limit how many Sessions to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Session upsert
|
|
*/
|
|
export type SessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Session to update in case it exists.
|
|
*/
|
|
where: SessionWhereUniqueInput
|
|
/**
|
|
* In case the Session found by the `where` argument doesn't exist, create a new Session with this data.
|
|
*/
|
|
create: XOR<SessionCreateInput, SessionUncheckedCreateInput>
|
|
/**
|
|
* In case the Session was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Session delete
|
|
*/
|
|
export type SessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Session to delete.
|
|
*/
|
|
where: SessionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Session deleteMany
|
|
*/
|
|
export type SessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Sessions to delete
|
|
*/
|
|
where?: SessionWhereInput
|
|
/**
|
|
* Limit how many Sessions to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Session without action
|
|
*/
|
|
export type SessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Session
|
|
*/
|
|
select?: SessionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Session
|
|
*/
|
|
omit?: SessionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SessionInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model VerificationToken
|
|
*/
|
|
|
|
export type AggregateVerificationToken = {
|
|
_count: VerificationTokenCountAggregateOutputType | null
|
|
_min: VerificationTokenMinAggregateOutputType | null
|
|
_max: VerificationTokenMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type VerificationTokenMinAggregateOutputType = {
|
|
identifier: string | null
|
|
token: string | null
|
|
expires: Date | null
|
|
}
|
|
|
|
export type VerificationTokenMaxAggregateOutputType = {
|
|
identifier: string | null
|
|
token: string | null
|
|
expires: Date | null
|
|
}
|
|
|
|
export type VerificationTokenCountAggregateOutputType = {
|
|
identifier: number
|
|
token: number
|
|
expires: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type VerificationTokenMinAggregateInputType = {
|
|
identifier?: true
|
|
token?: true
|
|
expires?: true
|
|
}
|
|
|
|
export type VerificationTokenMaxAggregateInputType = {
|
|
identifier?: true
|
|
token?: true
|
|
expires?: true
|
|
}
|
|
|
|
export type VerificationTokenCountAggregateInputType = {
|
|
identifier?: true
|
|
token?: true
|
|
expires?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type VerificationTokenAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which VerificationToken to aggregate.
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VerificationTokens to fetch.
|
|
*/
|
|
orderBy?: VerificationTokenOrderByWithRelationInput | VerificationTokenOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: VerificationTokenWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VerificationTokens from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` VerificationTokens.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned VerificationTokens
|
|
**/
|
|
_count?: true | VerificationTokenCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: VerificationTokenMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: VerificationTokenMaxAggregateInputType
|
|
}
|
|
|
|
export type GetVerificationTokenAggregateType<T extends VerificationTokenAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateVerificationToken]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateVerificationToken[P]>
|
|
: GetScalarType<T[P], AggregateVerificationToken[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type VerificationTokenGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: VerificationTokenWhereInput
|
|
orderBy?: VerificationTokenOrderByWithAggregationInput | VerificationTokenOrderByWithAggregationInput[]
|
|
by: VerificationTokenScalarFieldEnum[] | VerificationTokenScalarFieldEnum
|
|
having?: VerificationTokenScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: VerificationTokenCountAggregateInputType | true
|
|
_min?: VerificationTokenMinAggregateInputType
|
|
_max?: VerificationTokenMaxAggregateInputType
|
|
}
|
|
|
|
export type VerificationTokenGroupByOutputType = {
|
|
identifier: string
|
|
token: string
|
|
expires: Date
|
|
_count: VerificationTokenCountAggregateOutputType | null
|
|
_min: VerificationTokenMinAggregateOutputType | null
|
|
_max: VerificationTokenMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetVerificationTokenGroupByPayload<T extends VerificationTokenGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<VerificationTokenGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof VerificationTokenGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], VerificationTokenGroupByOutputType[P]>
|
|
: GetScalarType<T[P], VerificationTokenGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type VerificationTokenSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
identifier?: boolean
|
|
token?: boolean
|
|
expires?: boolean
|
|
}, ExtArgs["result"]["verificationToken"]>
|
|
|
|
export type VerificationTokenSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
identifier?: boolean
|
|
token?: boolean
|
|
expires?: boolean
|
|
}, ExtArgs["result"]["verificationToken"]>
|
|
|
|
export type VerificationTokenSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
identifier?: boolean
|
|
token?: boolean
|
|
expires?: boolean
|
|
}, ExtArgs["result"]["verificationToken"]>
|
|
|
|
export type VerificationTokenSelectScalar = {
|
|
identifier?: boolean
|
|
token?: boolean
|
|
expires?: boolean
|
|
}
|
|
|
|
export type VerificationTokenOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"identifier" | "token" | "expires", ExtArgs["result"]["verificationToken"]>
|
|
|
|
export type $VerificationTokenPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "VerificationToken"
|
|
objects: {}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
identifier: string
|
|
token: string
|
|
expires: Date
|
|
}, ExtArgs["result"]["verificationToken"]>
|
|
composites: {}
|
|
}
|
|
|
|
type VerificationTokenGetPayload<S extends boolean | null | undefined | VerificationTokenDefaultArgs> = $Result.GetResult<Prisma.$VerificationTokenPayload, S>
|
|
|
|
type VerificationTokenCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<VerificationTokenFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: VerificationTokenCountAggregateInputType | true
|
|
}
|
|
|
|
export interface VerificationTokenDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['VerificationToken'], meta: { name: 'VerificationToken' } }
|
|
/**
|
|
* Find zero or one VerificationToken that matches the filter.
|
|
* @param {VerificationTokenFindUniqueArgs} args - Arguments to find a VerificationToken
|
|
* @example
|
|
* // Get one VerificationToken
|
|
* const verificationToken = await prisma.verificationToken.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends VerificationTokenFindUniqueArgs>(args: SelectSubset<T, VerificationTokenFindUniqueArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one VerificationToken that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {VerificationTokenFindUniqueOrThrowArgs} args - Arguments to find a VerificationToken
|
|
* @example
|
|
* // Get one VerificationToken
|
|
* const verificationToken = await prisma.verificationToken.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends VerificationTokenFindUniqueOrThrowArgs>(args: SelectSubset<T, VerificationTokenFindUniqueOrThrowArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first VerificationToken that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenFindFirstArgs} args - Arguments to find a VerificationToken
|
|
* @example
|
|
* // Get one VerificationToken
|
|
* const verificationToken = await prisma.verificationToken.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends VerificationTokenFindFirstArgs>(args?: SelectSubset<T, VerificationTokenFindFirstArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first VerificationToken that matches the filter or
|
|
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenFindFirstOrThrowArgs} args - Arguments to find a VerificationToken
|
|
* @example
|
|
* // Get one VerificationToken
|
|
* const verificationToken = await prisma.verificationToken.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends VerificationTokenFindFirstOrThrowArgs>(args?: SelectSubset<T, VerificationTokenFindFirstOrThrowArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more VerificationTokens that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all VerificationTokens
|
|
* const verificationTokens = await prisma.verificationToken.findMany()
|
|
*
|
|
* // Get first 10 VerificationTokens
|
|
* const verificationTokens = await prisma.verificationToken.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `identifier`
|
|
* const verificationTokenWithIdentifierOnly = await prisma.verificationToken.findMany({ select: { identifier: true } })
|
|
*
|
|
*/
|
|
findMany<T extends VerificationTokenFindManyArgs>(args?: SelectSubset<T, VerificationTokenFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a VerificationToken.
|
|
* @param {VerificationTokenCreateArgs} args - Arguments to create a VerificationToken.
|
|
* @example
|
|
* // Create one VerificationToken
|
|
* const VerificationToken = await prisma.verificationToken.create({
|
|
* data: {
|
|
* // ... data to create a VerificationToken
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends VerificationTokenCreateArgs>(args: SelectSubset<T, VerificationTokenCreateArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many VerificationTokens.
|
|
* @param {VerificationTokenCreateManyArgs} args - Arguments to create many VerificationTokens.
|
|
* @example
|
|
* // Create many VerificationTokens
|
|
* const verificationToken = await prisma.verificationToken.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends VerificationTokenCreateManyArgs>(args?: SelectSubset<T, VerificationTokenCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many VerificationTokens and returns the data saved in the database.
|
|
* @param {VerificationTokenCreateManyAndReturnArgs} args - Arguments to create many VerificationTokens.
|
|
* @example
|
|
* // Create many VerificationTokens
|
|
* const verificationToken = await prisma.verificationToken.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many VerificationTokens and only return the `identifier`
|
|
* const verificationTokenWithIdentifierOnly = await prisma.verificationToken.createManyAndReturn({
|
|
* select: { identifier: true },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
createManyAndReturn<T extends VerificationTokenCreateManyAndReturnArgs>(args?: SelectSubset<T, VerificationTokenCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a VerificationToken.
|
|
* @param {VerificationTokenDeleteArgs} args - Arguments to delete one VerificationToken.
|
|
* @example
|
|
* // Delete one VerificationToken
|
|
* const VerificationToken = await prisma.verificationToken.delete({
|
|
* where: {
|
|
* // ... filter to delete one VerificationToken
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends VerificationTokenDeleteArgs>(args: SelectSubset<T, VerificationTokenDeleteArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one VerificationToken.
|
|
* @param {VerificationTokenUpdateArgs} args - Arguments to update one VerificationToken.
|
|
* @example
|
|
* // Update one VerificationToken
|
|
* const verificationToken = await prisma.verificationToken.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends VerificationTokenUpdateArgs>(args: SelectSubset<T, VerificationTokenUpdateArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more VerificationTokens.
|
|
* @param {VerificationTokenDeleteManyArgs} args - Arguments to filter VerificationTokens to delete.
|
|
* @example
|
|
* // Delete a few VerificationTokens
|
|
* const { count } = await prisma.verificationToken.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends VerificationTokenDeleteManyArgs>(args?: SelectSubset<T, VerificationTokenDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more VerificationTokens.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many VerificationTokens
|
|
* const verificationToken = await prisma.verificationToken.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends VerificationTokenUpdateManyArgs>(args: SelectSubset<T, VerificationTokenUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more VerificationTokens and returns the data updated in the database.
|
|
* @param {VerificationTokenUpdateManyAndReturnArgs} args - Arguments to update many VerificationTokens.
|
|
* @example
|
|
* // Update many VerificationTokens
|
|
* const verificationToken = await prisma.verificationToken.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more VerificationTokens and only return the `identifier`
|
|
* const verificationTokenWithIdentifierOnly = await prisma.verificationToken.updateManyAndReturn({
|
|
* select: { identifier: true },
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
*
|
|
*/
|
|
updateManyAndReturn<T extends VerificationTokenUpdateManyAndReturnArgs>(args: SelectSubset<T, VerificationTokenUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one VerificationToken.
|
|
* @param {VerificationTokenUpsertArgs} args - Arguments to update or create a VerificationToken.
|
|
* @example
|
|
* // Update or create a VerificationToken
|
|
* const verificationToken = await prisma.verificationToken.upsert({
|
|
* create: {
|
|
* // ... data to create a VerificationToken
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the VerificationToken we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends VerificationTokenUpsertArgs>(args: SelectSubset<T, VerificationTokenUpsertArgs<ExtArgs>>): Prisma__VerificationTokenClient<$Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of VerificationTokens.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenCountArgs} args - Arguments to filter VerificationTokens to count.
|
|
* @example
|
|
* // Count the number of VerificationTokens
|
|
* const count = await prisma.verificationToken.count({
|
|
* where: {
|
|
* // ... the filter for the VerificationTokens we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends VerificationTokenCountArgs>(
|
|
args?: Subset<T, VerificationTokenCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], VerificationTokenCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a VerificationToken.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends VerificationTokenAggregateArgs>(args: Subset<T, VerificationTokenAggregateArgs>): Prisma.PrismaPromise<GetVerificationTokenAggregateType<T>>
|
|
|
|
/**
|
|
* Group by VerificationToken.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VerificationTokenGroupByArgs} args - Group by arguments.
|
|
* @example
|
|
* // Group by city, order by createdAt, get count
|
|
* const result = await prisma.user.groupBy({
|
|
* by: ['city', 'createdAt'],
|
|
* orderBy: {
|
|
* createdAt: true
|
|
* },
|
|
* _count: {
|
|
* _all: true
|
|
* },
|
|
* })
|
|
*
|
|
**/
|
|
groupBy<
|
|
T extends VerificationTokenGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: VerificationTokenGroupByArgs['orderBy'] }
|
|
: { orderBy?: VerificationTokenGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, VerificationTokenGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetVerificationTokenGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the VerificationToken model
|
|
*/
|
|
readonly fields: VerificationTokenFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for VerificationToken.
|
|
* Why is this prefixed with `Prisma__`?
|
|
* Because we want to prevent naming conflicts as mentioned in
|
|
* https://github.com/prisma/prisma-client-js/issues/707
|
|
*/
|
|
export interface Prisma__VerificationTokenClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the VerificationToken model
|
|
*/
|
|
interface VerificationTokenFieldRefs {
|
|
readonly identifier: FieldRef<"VerificationToken", 'String'>
|
|
readonly token: FieldRef<"VerificationToken", 'String'>
|
|
readonly expires: FieldRef<"VerificationToken", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* VerificationToken findUnique
|
|
*/
|
|
export type VerificationTokenFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VerificationToken to fetch.
|
|
*/
|
|
where: VerificationTokenWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VerificationToken findUniqueOrThrow
|
|
*/
|
|
export type VerificationTokenFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VerificationToken to fetch.
|
|
*/
|
|
where: VerificationTokenWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VerificationToken findFirst
|
|
*/
|
|
export type VerificationTokenFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VerificationToken to fetch.
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VerificationTokens to fetch.
|
|
*/
|
|
orderBy?: VerificationTokenOrderByWithRelationInput | VerificationTokenOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for VerificationTokens.
|
|
*/
|
|
cursor?: VerificationTokenWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VerificationTokens from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` VerificationTokens.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of VerificationTokens.
|
|
*/
|
|
distinct?: VerificationTokenScalarFieldEnum | VerificationTokenScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* VerificationToken findFirstOrThrow
|
|
*/
|
|
export type VerificationTokenFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VerificationToken to fetch.
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VerificationTokens to fetch.
|
|
*/
|
|
orderBy?: VerificationTokenOrderByWithRelationInput | VerificationTokenOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for VerificationTokens.
|
|
*/
|
|
cursor?: VerificationTokenWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VerificationTokens from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` VerificationTokens.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of VerificationTokens.
|
|
*/
|
|
distinct?: VerificationTokenScalarFieldEnum | VerificationTokenScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* VerificationToken findMany
|
|
*/
|
|
export type VerificationTokenFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VerificationTokens to fetch.
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VerificationTokens to fetch.
|
|
*/
|
|
orderBy?: VerificationTokenOrderByWithRelationInput | VerificationTokenOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing VerificationTokens.
|
|
*/
|
|
cursor?: VerificationTokenWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VerificationTokens from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` VerificationTokens.
|
|
*/
|
|
skip?: number
|
|
distinct?: VerificationTokenScalarFieldEnum | VerificationTokenScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* VerificationToken create
|
|
*/
|
|
export type VerificationTokenCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a VerificationToken.
|
|
*/
|
|
data: XOR<VerificationTokenCreateInput, VerificationTokenUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* VerificationToken createMany
|
|
*/
|
|
export type VerificationTokenCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many VerificationTokens.
|
|
*/
|
|
data: VerificationTokenCreateManyInput | VerificationTokenCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* VerificationToken createManyAndReturn
|
|
*/
|
|
export type VerificationTokenCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many VerificationTokens.
|
|
*/
|
|
data: VerificationTokenCreateManyInput | VerificationTokenCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* VerificationToken update
|
|
*/
|
|
export type VerificationTokenUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a VerificationToken.
|
|
*/
|
|
data: XOR<VerificationTokenUpdateInput, VerificationTokenUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which VerificationToken to update.
|
|
*/
|
|
where: VerificationTokenWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VerificationToken updateMany
|
|
*/
|
|
export type VerificationTokenUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update VerificationTokens.
|
|
*/
|
|
data: XOR<VerificationTokenUpdateManyMutationInput, VerificationTokenUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which VerificationTokens to update
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* Limit how many VerificationTokens to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* VerificationToken updateManyAndReturn
|
|
*/
|
|
export type VerificationTokenUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update VerificationTokens.
|
|
*/
|
|
data: XOR<VerificationTokenUpdateManyMutationInput, VerificationTokenUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which VerificationTokens to update
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* Limit how many VerificationTokens to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* VerificationToken upsert
|
|
*/
|
|
export type VerificationTokenUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the VerificationToken to update in case it exists.
|
|
*/
|
|
where: VerificationTokenWhereUniqueInput
|
|
/**
|
|
* In case the VerificationToken found by the `where` argument doesn't exist, create a new VerificationToken with this data.
|
|
*/
|
|
create: XOR<VerificationTokenCreateInput, VerificationTokenUncheckedCreateInput>
|
|
/**
|
|
* In case the VerificationToken was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<VerificationTokenUpdateInput, VerificationTokenUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* VerificationToken delete
|
|
*/
|
|
export type VerificationTokenDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
/**
|
|
* Filter which VerificationToken to delete.
|
|
*/
|
|
where: VerificationTokenWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VerificationToken deleteMany
|
|
*/
|
|
export type VerificationTokenDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which VerificationTokens to delete
|
|
*/
|
|
where?: VerificationTokenWhereInput
|
|
/**
|
|
* Limit how many VerificationTokens to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* VerificationToken without action
|
|
*/
|
|
export type VerificationTokenDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VerificationToken
|
|
*/
|
|
select?: VerificationTokenSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VerificationToken
|
|
*/
|
|
omit?: VerificationTokenOmit<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Course
|
|
*/
|
|
|
|
export type AggregateCourse = {
|
|
_count: CourseCountAggregateOutputType | null
|
|
_avg: CourseAvgAggregateOutputType | null
|
|
_sum: CourseSumAggregateOutputType | null
|
|
_min: CourseMinAggregateOutputType | null
|
|
_max: CourseMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type CourseAvgAggregateOutputType = {
|
|
order: number | null
|
|
}
|
|
|
|
export type CourseSumAggregateOutputType = {
|
|
order: number | null
|
|
}
|
|
|
|
export type CourseMinAggregateOutputType = {
|
|
id: string | null
|
|
slug: string | null
|
|
category: $Enums.CourseCategory | null
|
|
level: $Enums.CourseLevel | null
|
|
thumbnailUrl: string | null
|
|
published: boolean | null
|
|
order: number | null
|
|
createdAt: Date | null
|
|
titleFr: string | null
|
|
titleEn: string | null
|
|
titleEs: string | null
|
|
descFr: string | null
|
|
descEn: string | null
|
|
descEs: string | null
|
|
}
|
|
|
|
export type CourseMaxAggregateOutputType = {
|
|
id: string | null
|
|
slug: string | null
|
|
category: $Enums.CourseCategory | null
|
|
level: $Enums.CourseLevel | null
|
|
thumbnailUrl: string | null
|
|
published: boolean | null
|
|
order: number | null
|
|
createdAt: Date | null
|
|
titleFr: string | null
|
|
titleEn: string | null
|
|
titleEs: string | null
|
|
descFr: string | null
|
|
descEn: string | null
|
|
descEs: string | null
|
|
}
|
|
|
|
export type CourseCountAggregateOutputType = {
|
|
id: number
|
|
slug: number
|
|
category: number
|
|
level: number
|
|
thumbnailUrl: number
|
|
published: number
|
|
order: number
|
|
createdAt: number
|
|
titleFr: number
|
|
titleEn: number
|
|
titleEs: number
|
|
descFr: number
|
|
descEn: number
|
|
descEs: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type CourseAvgAggregateInputType = {
|
|
order?: true
|
|
}
|
|
|
|
export type CourseSumAggregateInputType = {
|
|
order?: true
|
|
}
|
|
|
|
export type CourseMinAggregateInputType = {
|
|
id?: true
|
|
slug?: true
|
|
category?: true
|
|
level?: true
|
|
thumbnailUrl?: true
|
|
published?: true
|
|
order?: true
|
|
createdAt?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
descFr?: true
|
|
descEn?: true
|
|
descEs?: true
|
|
}
|
|
|
|
export type CourseMaxAggregateInputType = {
|
|
id?: true
|
|
slug?: true
|
|
category?: true
|
|
level?: true
|
|
thumbnailUrl?: true
|
|
published?: true
|
|
order?: true
|
|
createdAt?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
descFr?: true
|
|
descEn?: true
|
|
descEs?: true
|
|
}
|
|
|
|
export type CourseCountAggregateInputType = {
|
|
id?: true
|
|
slug?: true
|
|
category?: true
|
|
level?: true
|
|
thumbnailUrl?: true
|
|
published?: true
|
|
order?: true
|
|
createdAt?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
descFr?: true
|
|
descEn?: true
|
|
descEs?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type CourseAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Course to aggregate.
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Courses to fetch.
|
|
*/
|
|
orderBy?: CourseOrderByWithRelationInput | CourseOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: CourseWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Courses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Courses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Courses
|
|
**/
|
|
_count?: true | CourseCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: CourseAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: CourseSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: CourseMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: CourseMaxAggregateInputType
|
|
}
|
|
|
|
export type GetCourseAggregateType<T extends CourseAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateCourse]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateCourse[P]>
|
|
: GetScalarType<T[P], AggregateCourse[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type CourseGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: CourseWhereInput
|
|
orderBy?: CourseOrderByWithAggregationInput | CourseOrderByWithAggregationInput[]
|
|
by: CourseScalarFieldEnum[] | CourseScalarFieldEnum
|
|
having?: CourseScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: CourseCountAggregateInputType | true
|
|
_avg?: CourseAvgAggregateInputType
|
|
_sum?: CourseSumAggregateInputType
|
|
_min?: CourseMinAggregateInputType
|
|
_max?: CourseMaxAggregateInputType
|
|
}
|
|
|
|
export type CourseGroupByOutputType = {
|
|
id: string
|
|
slug: string
|
|
category: $Enums.CourseCategory
|
|
level: $Enums.CourseLevel
|
|
thumbnailUrl: string | null
|
|
published: boolean
|
|
order: number
|
|
createdAt: Date
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
_count: CourseCountAggregateOutputType | null
|
|
_avg: CourseAvgAggregateOutputType | null
|
|
_sum: CourseSumAggregateOutputType | null
|
|
_min: CourseMinAggregateOutputType | null
|
|
_max: CourseMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetCourseGroupByPayload<T extends CourseGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<CourseGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof CourseGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], CourseGroupByOutputType[P]>
|
|
: GetScalarType<T[P], CourseGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type CourseSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
slug?: boolean
|
|
category?: boolean
|
|
level?: boolean
|
|
thumbnailUrl?: boolean
|
|
published?: boolean
|
|
order?: boolean
|
|
createdAt?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
descFr?: boolean
|
|
descEn?: boolean
|
|
descEs?: boolean
|
|
modules?: boolean | Course$modulesArgs<ExtArgs>
|
|
enrollments?: boolean | Course$enrollmentsArgs<ExtArgs>
|
|
certificates?: boolean | Course$certificatesArgs<ExtArgs>
|
|
_count?: boolean | CourseCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["course"]>
|
|
|
|
export type CourseSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
slug?: boolean
|
|
category?: boolean
|
|
level?: boolean
|
|
thumbnailUrl?: boolean
|
|
published?: boolean
|
|
order?: boolean
|
|
createdAt?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
descFr?: boolean
|
|
descEn?: boolean
|
|
descEs?: boolean
|
|
}, ExtArgs["result"]["course"]>
|
|
|
|
export type CourseSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
slug?: boolean
|
|
category?: boolean
|
|
level?: boolean
|
|
thumbnailUrl?: boolean
|
|
published?: boolean
|
|
order?: boolean
|
|
createdAt?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
descFr?: boolean
|
|
descEn?: boolean
|
|
descEs?: boolean
|
|
}, ExtArgs["result"]["course"]>
|
|
|
|
export type CourseSelectScalar = {
|
|
id?: boolean
|
|
slug?: boolean
|
|
category?: boolean
|
|
level?: boolean
|
|
thumbnailUrl?: boolean
|
|
published?: boolean
|
|
order?: boolean
|
|
createdAt?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
descFr?: boolean
|
|
descEn?: boolean
|
|
descEs?: boolean
|
|
}
|
|
|
|
export type CourseOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "slug" | "category" | "level" | "thumbnailUrl" | "published" | "order" | "createdAt" | "titleFr" | "titleEn" | "titleEs" | "descFr" | "descEn" | "descEs", ExtArgs["result"]["course"]>
|
|
export type CourseInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
modules?: boolean | Course$modulesArgs<ExtArgs>
|
|
enrollments?: boolean | Course$enrollmentsArgs<ExtArgs>
|
|
certificates?: boolean | Course$certificatesArgs<ExtArgs>
|
|
_count?: boolean | CourseCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type CourseIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
export type CourseIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $CoursePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Course"
|
|
objects: {
|
|
modules: Prisma.$ModulePayload<ExtArgs>[]
|
|
enrollments: Prisma.$EnrollmentPayload<ExtArgs>[]
|
|
certificates: Prisma.$CertificatePayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
slug: string
|
|
category: $Enums.CourseCategory
|
|
level: $Enums.CourseLevel
|
|
thumbnailUrl: string | null
|
|
published: boolean
|
|
order: number
|
|
createdAt: Date
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
}, ExtArgs["result"]["course"]>
|
|
composites: {}
|
|
}
|
|
|
|
type CourseGetPayload<S extends boolean | null | undefined | CourseDefaultArgs> = $Result.GetResult<Prisma.$CoursePayload, S>
|
|
|
|
type CourseCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<CourseFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: CourseCountAggregateInputType | true
|
|
}
|
|
|
|
export interface CourseDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Course'], meta: { name: 'Course' } }
|
|
/**
|
|
* Find zero or one Course that matches the filter.
|
|
* @param {CourseFindUniqueArgs} args - Arguments to find a Course
|
|
* @example
|
|
* // Get one Course
|
|
* const course = await prisma.course.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends CourseFindUniqueArgs>(args: SelectSubset<T, CourseFindUniqueArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Course that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {CourseFindUniqueOrThrowArgs} args - Arguments to find a Course
|
|
* @example
|
|
* // Get one Course
|
|
* const course = await prisma.course.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends CourseFindUniqueOrThrowArgs>(args: SelectSubset<T, CourseFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Course 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 {CourseFindFirstArgs} args - Arguments to find a Course
|
|
* @example
|
|
* // Get one Course
|
|
* const course = await prisma.course.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends CourseFindFirstArgs>(args?: SelectSubset<T, CourseFindFirstArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Course 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 {CourseFindFirstOrThrowArgs} args - Arguments to find a Course
|
|
* @example
|
|
* // Get one Course
|
|
* const course = await prisma.course.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends CourseFindFirstOrThrowArgs>(args?: SelectSubset<T, CourseFindFirstOrThrowArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Courses 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 {CourseFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Courses
|
|
* const courses = await prisma.course.findMany()
|
|
*
|
|
* // Get first 10 Courses
|
|
* const courses = await prisma.course.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const courseWithIdOnly = await prisma.course.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends CourseFindManyArgs>(args?: SelectSubset<T, CourseFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Course.
|
|
* @param {CourseCreateArgs} args - Arguments to create a Course.
|
|
* @example
|
|
* // Create one Course
|
|
* const Course = await prisma.course.create({
|
|
* data: {
|
|
* // ... data to create a Course
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends CourseCreateArgs>(args: SelectSubset<T, CourseCreateArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Courses.
|
|
* @param {CourseCreateManyArgs} args - Arguments to create many Courses.
|
|
* @example
|
|
* // Create many Courses
|
|
* const course = await prisma.course.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends CourseCreateManyArgs>(args?: SelectSubset<T, CourseCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Courses and returns the data saved in the database.
|
|
* @param {CourseCreateManyAndReturnArgs} args - Arguments to create many Courses.
|
|
* @example
|
|
* // Create many Courses
|
|
* const course = await prisma.course.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Courses and only return the `id`
|
|
* const courseWithIdOnly = await prisma.course.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 CourseCreateManyAndReturnArgs>(args?: SelectSubset<T, CourseCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Course.
|
|
* @param {CourseDeleteArgs} args - Arguments to delete one Course.
|
|
* @example
|
|
* // Delete one Course
|
|
* const Course = await prisma.course.delete({
|
|
* where: {
|
|
* // ... filter to delete one Course
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends CourseDeleteArgs>(args: SelectSubset<T, CourseDeleteArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Course.
|
|
* @param {CourseUpdateArgs} args - Arguments to update one Course.
|
|
* @example
|
|
* // Update one Course
|
|
* const course = await prisma.course.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends CourseUpdateArgs>(args: SelectSubset<T, CourseUpdateArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Courses.
|
|
* @param {CourseDeleteManyArgs} args - Arguments to filter Courses to delete.
|
|
* @example
|
|
* // Delete a few Courses
|
|
* const { count } = await prisma.course.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends CourseDeleteManyArgs>(args?: SelectSubset<T, CourseDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Courses.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CourseUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Courses
|
|
* const course = await prisma.course.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends CourseUpdateManyArgs>(args: SelectSubset<T, CourseUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Courses and returns the data updated in the database.
|
|
* @param {CourseUpdateManyAndReturnArgs} args - Arguments to update many Courses.
|
|
* @example
|
|
* // Update many Courses
|
|
* const course = await prisma.course.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Courses and only return the `id`
|
|
* const courseWithIdOnly = await prisma.course.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 CourseUpdateManyAndReturnArgs>(args: SelectSubset<T, CourseUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Course.
|
|
* @param {CourseUpsertArgs} args - Arguments to update or create a Course.
|
|
* @example
|
|
* // Update or create a Course
|
|
* const course = await prisma.course.upsert({
|
|
* create: {
|
|
* // ... data to create a Course
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Course we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends CourseUpsertArgs>(args: SelectSubset<T, CourseUpsertArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Courses.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CourseCountArgs} args - Arguments to filter Courses to count.
|
|
* @example
|
|
* // Count the number of Courses
|
|
* const count = await prisma.course.count({
|
|
* where: {
|
|
* // ... the filter for the Courses we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends CourseCountArgs>(
|
|
args?: Subset<T, CourseCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], CourseCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Course.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CourseAggregateArgs} 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 CourseAggregateArgs>(args: Subset<T, CourseAggregateArgs>): Prisma.PrismaPromise<GetCourseAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Course.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CourseGroupByArgs} 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 CourseGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: CourseGroupByArgs['orderBy'] }
|
|
: { orderBy?: CourseGroupByArgs['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, CourseGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCourseGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Course model
|
|
*/
|
|
readonly fields: CourseFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Course.
|
|
* 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__CourseClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
modules<T extends Course$modulesArgs<ExtArgs> = {}>(args?: Subset<T, Course$modulesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
enrollments<T extends Course$enrollmentsArgs<ExtArgs> = {}>(args?: Subset<T, Course$enrollmentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
certificates<T extends Course$certificatesArgs<ExtArgs> = {}>(args?: Subset<T, Course$certificatesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CertificatePayload<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 Course model
|
|
*/
|
|
interface CourseFieldRefs {
|
|
readonly id: FieldRef<"Course", 'String'>
|
|
readonly slug: FieldRef<"Course", 'String'>
|
|
readonly category: FieldRef<"Course", 'CourseCategory'>
|
|
readonly level: FieldRef<"Course", 'CourseLevel'>
|
|
readonly thumbnailUrl: FieldRef<"Course", 'String'>
|
|
readonly published: FieldRef<"Course", 'Boolean'>
|
|
readonly order: FieldRef<"Course", 'Int'>
|
|
readonly createdAt: FieldRef<"Course", 'DateTime'>
|
|
readonly titleFr: FieldRef<"Course", 'String'>
|
|
readonly titleEn: FieldRef<"Course", 'String'>
|
|
readonly titleEs: FieldRef<"Course", 'String'>
|
|
readonly descFr: FieldRef<"Course", 'String'>
|
|
readonly descEn: FieldRef<"Course", 'String'>
|
|
readonly descEs: FieldRef<"Course", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Course findUnique
|
|
*/
|
|
export type CourseFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Course to fetch.
|
|
*/
|
|
where: CourseWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Course findUniqueOrThrow
|
|
*/
|
|
export type CourseFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Course to fetch.
|
|
*/
|
|
where: CourseWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Course findFirst
|
|
*/
|
|
export type CourseFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Course to fetch.
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Courses to fetch.
|
|
*/
|
|
orderBy?: CourseOrderByWithRelationInput | CourseOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Courses.
|
|
*/
|
|
cursor?: CourseWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Courses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Courses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Courses.
|
|
*/
|
|
distinct?: CourseScalarFieldEnum | CourseScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Course findFirstOrThrow
|
|
*/
|
|
export type CourseFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Course to fetch.
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Courses to fetch.
|
|
*/
|
|
orderBy?: CourseOrderByWithRelationInput | CourseOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Courses.
|
|
*/
|
|
cursor?: CourseWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Courses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Courses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Courses.
|
|
*/
|
|
distinct?: CourseScalarFieldEnum | CourseScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Course findMany
|
|
*/
|
|
export type CourseFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Courses to fetch.
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Courses to fetch.
|
|
*/
|
|
orderBy?: CourseOrderByWithRelationInput | CourseOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Courses.
|
|
*/
|
|
cursor?: CourseWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Courses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Courses.
|
|
*/
|
|
skip?: number
|
|
distinct?: CourseScalarFieldEnum | CourseScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Course create
|
|
*/
|
|
export type CourseCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Course.
|
|
*/
|
|
data: XOR<CourseCreateInput, CourseUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Course createMany
|
|
*/
|
|
export type CourseCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Courses.
|
|
*/
|
|
data: CourseCreateManyInput | CourseCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Course createManyAndReturn
|
|
*/
|
|
export type CourseCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Courses.
|
|
*/
|
|
data: CourseCreateManyInput | CourseCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Course update
|
|
*/
|
|
export type CourseUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Course.
|
|
*/
|
|
data: XOR<CourseUpdateInput, CourseUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Course to update.
|
|
*/
|
|
where: CourseWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Course updateMany
|
|
*/
|
|
export type CourseUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Courses.
|
|
*/
|
|
data: XOR<CourseUpdateManyMutationInput, CourseUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Courses to update
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* Limit how many Courses to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Course updateManyAndReturn
|
|
*/
|
|
export type CourseUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Courses.
|
|
*/
|
|
data: XOR<CourseUpdateManyMutationInput, CourseUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Courses to update
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* Limit how many Courses to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Course upsert
|
|
*/
|
|
export type CourseUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Course to update in case it exists.
|
|
*/
|
|
where: CourseWhereUniqueInput
|
|
/**
|
|
* In case the Course found by the `where` argument doesn't exist, create a new Course with this data.
|
|
*/
|
|
create: XOR<CourseCreateInput, CourseUncheckedCreateInput>
|
|
/**
|
|
* In case the Course was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<CourseUpdateInput, CourseUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Course delete
|
|
*/
|
|
export type CourseDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Course to delete.
|
|
*/
|
|
where: CourseWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Course deleteMany
|
|
*/
|
|
export type CourseDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Courses to delete
|
|
*/
|
|
where?: CourseWhereInput
|
|
/**
|
|
* Limit how many Courses to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Course.modules
|
|
*/
|
|
export type Course$modulesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
where?: ModuleWhereInput
|
|
orderBy?: ModuleOrderByWithRelationInput | ModuleOrderByWithRelationInput[]
|
|
cursor?: ModuleWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: ModuleScalarFieldEnum | ModuleScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Course.enrollments
|
|
*/
|
|
export type Course$enrollmentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
where?: EnrollmentWhereInput
|
|
orderBy?: EnrollmentOrderByWithRelationInput | EnrollmentOrderByWithRelationInput[]
|
|
cursor?: EnrollmentWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: EnrollmentScalarFieldEnum | EnrollmentScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Course.certificates
|
|
*/
|
|
export type Course$certificatesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
where?: CertificateWhereInput
|
|
orderBy?: CertificateOrderByWithRelationInput | CertificateOrderByWithRelationInput[]
|
|
cursor?: CertificateWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: CertificateScalarFieldEnum | CertificateScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Course without action
|
|
*/
|
|
export type CourseDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Course
|
|
*/
|
|
select?: CourseSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Course
|
|
*/
|
|
omit?: CourseOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CourseInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Module
|
|
*/
|
|
|
|
export type AggregateModule = {
|
|
_count: ModuleCountAggregateOutputType | null
|
|
_avg: ModuleAvgAggregateOutputType | null
|
|
_sum: ModuleSumAggregateOutputType | null
|
|
_min: ModuleMinAggregateOutputType | null
|
|
_max: ModuleMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type ModuleAvgAggregateOutputType = {
|
|
order: number | null
|
|
}
|
|
|
|
export type ModuleSumAggregateOutputType = {
|
|
order: number | null
|
|
}
|
|
|
|
export type ModuleMinAggregateOutputType = {
|
|
id: string | null
|
|
courseId: string | null
|
|
order: number | null
|
|
titleFr: string | null
|
|
titleEn: string | null
|
|
titleEs: string | null
|
|
}
|
|
|
|
export type ModuleMaxAggregateOutputType = {
|
|
id: string | null
|
|
courseId: string | null
|
|
order: number | null
|
|
titleFr: string | null
|
|
titleEn: string | null
|
|
titleEs: string | null
|
|
}
|
|
|
|
export type ModuleCountAggregateOutputType = {
|
|
id: number
|
|
courseId: number
|
|
order: number
|
|
titleFr: number
|
|
titleEn: number
|
|
titleEs: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type ModuleAvgAggregateInputType = {
|
|
order?: true
|
|
}
|
|
|
|
export type ModuleSumAggregateInputType = {
|
|
order?: true
|
|
}
|
|
|
|
export type ModuleMinAggregateInputType = {
|
|
id?: true
|
|
courseId?: true
|
|
order?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
}
|
|
|
|
export type ModuleMaxAggregateInputType = {
|
|
id?: true
|
|
courseId?: true
|
|
order?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
}
|
|
|
|
export type ModuleCountAggregateInputType = {
|
|
id?: true
|
|
courseId?: true
|
|
order?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type ModuleAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Module to aggregate.
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Modules to fetch.
|
|
*/
|
|
orderBy?: ModuleOrderByWithRelationInput | ModuleOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: ModuleWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Modules from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Modules.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Modules
|
|
**/
|
|
_count?: true | ModuleCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: ModuleAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: ModuleSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: ModuleMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: ModuleMaxAggregateInputType
|
|
}
|
|
|
|
export type GetModuleAggregateType<T extends ModuleAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateModule]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateModule[P]>
|
|
: GetScalarType<T[P], AggregateModule[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type ModuleGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ModuleWhereInput
|
|
orderBy?: ModuleOrderByWithAggregationInput | ModuleOrderByWithAggregationInput[]
|
|
by: ModuleScalarFieldEnum[] | ModuleScalarFieldEnum
|
|
having?: ModuleScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: ModuleCountAggregateInputType | true
|
|
_avg?: ModuleAvgAggregateInputType
|
|
_sum?: ModuleSumAggregateInputType
|
|
_min?: ModuleMinAggregateInputType
|
|
_max?: ModuleMaxAggregateInputType
|
|
}
|
|
|
|
export type ModuleGroupByOutputType = {
|
|
id: string
|
|
courseId: string
|
|
order: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
_count: ModuleCountAggregateOutputType | null
|
|
_avg: ModuleAvgAggregateOutputType | null
|
|
_sum: ModuleSumAggregateOutputType | null
|
|
_min: ModuleMinAggregateOutputType | null
|
|
_max: ModuleMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetModuleGroupByPayload<T extends ModuleGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<ModuleGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof ModuleGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], ModuleGroupByOutputType[P]>
|
|
: GetScalarType<T[P], ModuleGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type ModuleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
courseId?: boolean
|
|
order?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
lessons?: boolean | Module$lessonsArgs<ExtArgs>
|
|
quiz?: boolean | Module$quizArgs<ExtArgs>
|
|
_count?: boolean | ModuleCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["module"]>
|
|
|
|
export type ModuleSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
courseId?: boolean
|
|
order?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["module"]>
|
|
|
|
export type ModuleSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
courseId?: boolean
|
|
order?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["module"]>
|
|
|
|
export type ModuleSelectScalar = {
|
|
id?: boolean
|
|
courseId?: boolean
|
|
order?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
}
|
|
|
|
export type ModuleOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "courseId" | "order" | "titleFr" | "titleEn" | "titleEs", ExtArgs["result"]["module"]>
|
|
export type ModuleInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
lessons?: boolean | Module$lessonsArgs<ExtArgs>
|
|
quiz?: boolean | Module$quizArgs<ExtArgs>
|
|
_count?: boolean | ModuleCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type ModuleIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
export type ModuleIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $ModulePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Module"
|
|
objects: {
|
|
course: Prisma.$CoursePayload<ExtArgs>
|
|
lessons: Prisma.$LessonPayload<ExtArgs>[]
|
|
quiz: Prisma.$QuizPayload<ExtArgs> | null
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
courseId: string
|
|
order: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
}, ExtArgs["result"]["module"]>
|
|
composites: {}
|
|
}
|
|
|
|
type ModuleGetPayload<S extends boolean | null | undefined | ModuleDefaultArgs> = $Result.GetResult<Prisma.$ModulePayload, S>
|
|
|
|
type ModuleCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<ModuleFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: ModuleCountAggregateInputType | true
|
|
}
|
|
|
|
export interface ModuleDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Module'], meta: { name: 'Module' } }
|
|
/**
|
|
* Find zero or one Module that matches the filter.
|
|
* @param {ModuleFindUniqueArgs} args - Arguments to find a Module
|
|
* @example
|
|
* // Get one Module
|
|
* const module = await prisma.module.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends ModuleFindUniqueArgs>(args: SelectSubset<T, ModuleFindUniqueArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Module that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {ModuleFindUniqueOrThrowArgs} args - Arguments to find a Module
|
|
* @example
|
|
* // Get one Module
|
|
* const module = await prisma.module.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends ModuleFindUniqueOrThrowArgs>(args: SelectSubset<T, ModuleFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Module 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 {ModuleFindFirstArgs} args - Arguments to find a Module
|
|
* @example
|
|
* // Get one Module
|
|
* const module = await prisma.module.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends ModuleFindFirstArgs>(args?: SelectSubset<T, ModuleFindFirstArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Module 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 {ModuleFindFirstOrThrowArgs} args - Arguments to find a Module
|
|
* @example
|
|
* // Get one Module
|
|
* const module = await prisma.module.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends ModuleFindFirstOrThrowArgs>(args?: SelectSubset<T, ModuleFindFirstOrThrowArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Modules 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 {ModuleFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Modules
|
|
* const modules = await prisma.module.findMany()
|
|
*
|
|
* // Get first 10 Modules
|
|
* const modules = await prisma.module.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const moduleWithIdOnly = await prisma.module.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends ModuleFindManyArgs>(args?: SelectSubset<T, ModuleFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Module.
|
|
* @param {ModuleCreateArgs} args - Arguments to create a Module.
|
|
* @example
|
|
* // Create one Module
|
|
* const Module = await prisma.module.create({
|
|
* data: {
|
|
* // ... data to create a Module
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends ModuleCreateArgs>(args: SelectSubset<T, ModuleCreateArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Modules.
|
|
* @param {ModuleCreateManyArgs} args - Arguments to create many Modules.
|
|
* @example
|
|
* // Create many Modules
|
|
* const module = await prisma.module.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends ModuleCreateManyArgs>(args?: SelectSubset<T, ModuleCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Modules and returns the data saved in the database.
|
|
* @param {ModuleCreateManyAndReturnArgs} args - Arguments to create many Modules.
|
|
* @example
|
|
* // Create many Modules
|
|
* const module = await prisma.module.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Modules and only return the `id`
|
|
* const moduleWithIdOnly = await prisma.module.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 ModuleCreateManyAndReturnArgs>(args?: SelectSubset<T, ModuleCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Module.
|
|
* @param {ModuleDeleteArgs} args - Arguments to delete one Module.
|
|
* @example
|
|
* // Delete one Module
|
|
* const Module = await prisma.module.delete({
|
|
* where: {
|
|
* // ... filter to delete one Module
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends ModuleDeleteArgs>(args: SelectSubset<T, ModuleDeleteArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Module.
|
|
* @param {ModuleUpdateArgs} args - Arguments to update one Module.
|
|
* @example
|
|
* // Update one Module
|
|
* const module = await prisma.module.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends ModuleUpdateArgs>(args: SelectSubset<T, ModuleUpdateArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Modules.
|
|
* @param {ModuleDeleteManyArgs} args - Arguments to filter Modules to delete.
|
|
* @example
|
|
* // Delete a few Modules
|
|
* const { count } = await prisma.module.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends ModuleDeleteManyArgs>(args?: SelectSubset<T, ModuleDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Modules.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ModuleUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Modules
|
|
* const module = await prisma.module.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends ModuleUpdateManyArgs>(args: SelectSubset<T, ModuleUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Modules and returns the data updated in the database.
|
|
* @param {ModuleUpdateManyAndReturnArgs} args - Arguments to update many Modules.
|
|
* @example
|
|
* // Update many Modules
|
|
* const module = await prisma.module.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Modules and only return the `id`
|
|
* const moduleWithIdOnly = await prisma.module.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 ModuleUpdateManyAndReturnArgs>(args: SelectSubset<T, ModuleUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Module.
|
|
* @param {ModuleUpsertArgs} args - Arguments to update or create a Module.
|
|
* @example
|
|
* // Update or create a Module
|
|
* const module = await prisma.module.upsert({
|
|
* create: {
|
|
* // ... data to create a Module
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Module we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends ModuleUpsertArgs>(args: SelectSubset<T, ModuleUpsertArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Modules.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ModuleCountArgs} args - Arguments to filter Modules to count.
|
|
* @example
|
|
* // Count the number of Modules
|
|
* const count = await prisma.module.count({
|
|
* where: {
|
|
* // ... the filter for the Modules we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends ModuleCountArgs>(
|
|
args?: Subset<T, ModuleCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], ModuleCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Module.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ModuleAggregateArgs} 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 ModuleAggregateArgs>(args: Subset<T, ModuleAggregateArgs>): Prisma.PrismaPromise<GetModuleAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Module.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ModuleGroupByArgs} 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 ModuleGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: ModuleGroupByArgs['orderBy'] }
|
|
: { orderBy?: ModuleGroupByArgs['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, ModuleGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetModuleGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Module model
|
|
*/
|
|
readonly fields: ModuleFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Module.
|
|
* 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__ModuleClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
course<T extends CourseDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CourseDefaultArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
lessons<T extends Module$lessonsArgs<ExtArgs> = {}>(args?: Subset<T, Module$lessonsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
quiz<T extends Module$quizArgs<ExtArgs> = {}>(args?: Subset<T, Module$quizArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<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 Module model
|
|
*/
|
|
interface ModuleFieldRefs {
|
|
readonly id: FieldRef<"Module", 'String'>
|
|
readonly courseId: FieldRef<"Module", 'String'>
|
|
readonly order: FieldRef<"Module", 'Int'>
|
|
readonly titleFr: FieldRef<"Module", 'String'>
|
|
readonly titleEn: FieldRef<"Module", 'String'>
|
|
readonly titleEs: FieldRef<"Module", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Module findUnique
|
|
*/
|
|
export type ModuleFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Module to fetch.
|
|
*/
|
|
where: ModuleWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Module findUniqueOrThrow
|
|
*/
|
|
export type ModuleFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Module to fetch.
|
|
*/
|
|
where: ModuleWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Module findFirst
|
|
*/
|
|
export type ModuleFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Module to fetch.
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Modules to fetch.
|
|
*/
|
|
orderBy?: ModuleOrderByWithRelationInput | ModuleOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Modules.
|
|
*/
|
|
cursor?: ModuleWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Modules from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Modules.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Modules.
|
|
*/
|
|
distinct?: ModuleScalarFieldEnum | ModuleScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Module findFirstOrThrow
|
|
*/
|
|
export type ModuleFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Module to fetch.
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Modules to fetch.
|
|
*/
|
|
orderBy?: ModuleOrderByWithRelationInput | ModuleOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Modules.
|
|
*/
|
|
cursor?: ModuleWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Modules from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Modules.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Modules.
|
|
*/
|
|
distinct?: ModuleScalarFieldEnum | ModuleScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Module findMany
|
|
*/
|
|
export type ModuleFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Modules to fetch.
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Modules to fetch.
|
|
*/
|
|
orderBy?: ModuleOrderByWithRelationInput | ModuleOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Modules.
|
|
*/
|
|
cursor?: ModuleWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Modules from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Modules.
|
|
*/
|
|
skip?: number
|
|
distinct?: ModuleScalarFieldEnum | ModuleScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Module create
|
|
*/
|
|
export type ModuleCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Module.
|
|
*/
|
|
data: XOR<ModuleCreateInput, ModuleUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Module createMany
|
|
*/
|
|
export type ModuleCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Modules.
|
|
*/
|
|
data: ModuleCreateManyInput | ModuleCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Module createManyAndReturn
|
|
*/
|
|
export type ModuleCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Modules.
|
|
*/
|
|
data: ModuleCreateManyInput | ModuleCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Module update
|
|
*/
|
|
export type ModuleUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Module.
|
|
*/
|
|
data: XOR<ModuleUpdateInput, ModuleUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Module to update.
|
|
*/
|
|
where: ModuleWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Module updateMany
|
|
*/
|
|
export type ModuleUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Modules.
|
|
*/
|
|
data: XOR<ModuleUpdateManyMutationInput, ModuleUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Modules to update
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* Limit how many Modules to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Module updateManyAndReturn
|
|
*/
|
|
export type ModuleUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Modules.
|
|
*/
|
|
data: XOR<ModuleUpdateManyMutationInput, ModuleUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Modules to update
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* Limit how many Modules to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Module upsert
|
|
*/
|
|
export type ModuleUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Module to update in case it exists.
|
|
*/
|
|
where: ModuleWhereUniqueInput
|
|
/**
|
|
* In case the Module found by the `where` argument doesn't exist, create a new Module with this data.
|
|
*/
|
|
create: XOR<ModuleCreateInput, ModuleUncheckedCreateInput>
|
|
/**
|
|
* In case the Module was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<ModuleUpdateInput, ModuleUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Module delete
|
|
*/
|
|
export type ModuleDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Module to delete.
|
|
*/
|
|
where: ModuleWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Module deleteMany
|
|
*/
|
|
export type ModuleDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Modules to delete
|
|
*/
|
|
where?: ModuleWhereInput
|
|
/**
|
|
* Limit how many Modules to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Module.lessons
|
|
*/
|
|
export type Module$lessonsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
where?: LessonWhereInput
|
|
orderBy?: LessonOrderByWithRelationInput | LessonOrderByWithRelationInput[]
|
|
cursor?: LessonWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: LessonScalarFieldEnum | LessonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Module.quiz
|
|
*/
|
|
export type Module$quizArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
where?: QuizWhereInput
|
|
}
|
|
|
|
/**
|
|
* Module without action
|
|
*/
|
|
export type ModuleDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Module
|
|
*/
|
|
select?: ModuleSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Module
|
|
*/
|
|
omit?: ModuleOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ModuleInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Lesson
|
|
*/
|
|
|
|
export type AggregateLesson = {
|
|
_count: LessonCountAggregateOutputType | null
|
|
_avg: LessonAvgAggregateOutputType | null
|
|
_sum: LessonSumAggregateOutputType | null
|
|
_min: LessonMinAggregateOutputType | null
|
|
_max: LessonMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type LessonAvgAggregateOutputType = {
|
|
order: number | null
|
|
duration: number | null
|
|
}
|
|
|
|
export type LessonSumAggregateOutputType = {
|
|
order: number | null
|
|
duration: number | null
|
|
}
|
|
|
|
export type LessonMinAggregateOutputType = {
|
|
id: string | null
|
|
moduleId: string | null
|
|
order: number | null
|
|
type: $Enums.LessonType | null
|
|
videoUrl: string | null
|
|
duration: number | null
|
|
titleFr: string | null
|
|
titleEn: string | null
|
|
titleEs: string | null
|
|
contentFr: string | null
|
|
contentEn: string | null
|
|
contentEs: string | null
|
|
}
|
|
|
|
export type LessonMaxAggregateOutputType = {
|
|
id: string | null
|
|
moduleId: string | null
|
|
order: number | null
|
|
type: $Enums.LessonType | null
|
|
videoUrl: string | null
|
|
duration: number | null
|
|
titleFr: string | null
|
|
titleEn: string | null
|
|
titleEs: string | null
|
|
contentFr: string | null
|
|
contentEn: string | null
|
|
contentEs: string | null
|
|
}
|
|
|
|
export type LessonCountAggregateOutputType = {
|
|
id: number
|
|
moduleId: number
|
|
order: number
|
|
type: number
|
|
videoUrl: number
|
|
duration: number
|
|
titleFr: number
|
|
titleEn: number
|
|
titleEs: number
|
|
contentFr: number
|
|
contentEn: number
|
|
contentEs: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type LessonAvgAggregateInputType = {
|
|
order?: true
|
|
duration?: true
|
|
}
|
|
|
|
export type LessonSumAggregateInputType = {
|
|
order?: true
|
|
duration?: true
|
|
}
|
|
|
|
export type LessonMinAggregateInputType = {
|
|
id?: true
|
|
moduleId?: true
|
|
order?: true
|
|
type?: true
|
|
videoUrl?: true
|
|
duration?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
contentFr?: true
|
|
contentEn?: true
|
|
contentEs?: true
|
|
}
|
|
|
|
export type LessonMaxAggregateInputType = {
|
|
id?: true
|
|
moduleId?: true
|
|
order?: true
|
|
type?: true
|
|
videoUrl?: true
|
|
duration?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
contentFr?: true
|
|
contentEn?: true
|
|
contentEs?: true
|
|
}
|
|
|
|
export type LessonCountAggregateInputType = {
|
|
id?: true
|
|
moduleId?: true
|
|
order?: true
|
|
type?: true
|
|
videoUrl?: true
|
|
duration?: true
|
|
titleFr?: true
|
|
titleEn?: true
|
|
titleEs?: true
|
|
contentFr?: true
|
|
contentEn?: true
|
|
contentEs?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type LessonAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Lesson to aggregate.
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Lessons to fetch.
|
|
*/
|
|
orderBy?: LessonOrderByWithRelationInput | LessonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: LessonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Lessons from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Lessons.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Lessons
|
|
**/
|
|
_count?: true | LessonCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: LessonAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: LessonSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: LessonMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: LessonMaxAggregateInputType
|
|
}
|
|
|
|
export type GetLessonAggregateType<T extends LessonAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateLesson]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateLesson[P]>
|
|
: GetScalarType<T[P], AggregateLesson[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type LessonGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: LessonWhereInput
|
|
orderBy?: LessonOrderByWithAggregationInput | LessonOrderByWithAggregationInput[]
|
|
by: LessonScalarFieldEnum[] | LessonScalarFieldEnum
|
|
having?: LessonScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: LessonCountAggregateInputType | true
|
|
_avg?: LessonAvgAggregateInputType
|
|
_sum?: LessonSumAggregateInputType
|
|
_min?: LessonMinAggregateInputType
|
|
_max?: LessonMaxAggregateInputType
|
|
}
|
|
|
|
export type LessonGroupByOutputType = {
|
|
id: string
|
|
moduleId: string
|
|
order: number
|
|
type: $Enums.LessonType
|
|
videoUrl: string | null
|
|
duration: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr: string | null
|
|
contentEn: string | null
|
|
contentEs: string | null
|
|
_count: LessonCountAggregateOutputType | null
|
|
_avg: LessonAvgAggregateOutputType | null
|
|
_sum: LessonSumAggregateOutputType | null
|
|
_min: LessonMinAggregateOutputType | null
|
|
_max: LessonMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetLessonGroupByPayload<T extends LessonGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<LessonGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof LessonGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], LessonGroupByOutputType[P]>
|
|
: GetScalarType<T[P], LessonGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type LessonSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
order?: boolean
|
|
type?: boolean
|
|
videoUrl?: boolean
|
|
duration?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
contentFr?: boolean
|
|
contentEn?: boolean
|
|
contentEs?: boolean
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
lessonProgress?: boolean | Lesson$lessonProgressArgs<ExtArgs>
|
|
_count?: boolean | LessonCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["lesson"]>
|
|
|
|
export type LessonSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
order?: boolean
|
|
type?: boolean
|
|
videoUrl?: boolean
|
|
duration?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
contentFr?: boolean
|
|
contentEn?: boolean
|
|
contentEs?: boolean
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["lesson"]>
|
|
|
|
export type LessonSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
order?: boolean
|
|
type?: boolean
|
|
videoUrl?: boolean
|
|
duration?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
contentFr?: boolean
|
|
contentEn?: boolean
|
|
contentEs?: boolean
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["lesson"]>
|
|
|
|
export type LessonSelectScalar = {
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
order?: boolean
|
|
type?: boolean
|
|
videoUrl?: boolean
|
|
duration?: boolean
|
|
titleFr?: boolean
|
|
titleEn?: boolean
|
|
titleEs?: boolean
|
|
contentFr?: boolean
|
|
contentEn?: boolean
|
|
contentEs?: boolean
|
|
}
|
|
|
|
export type LessonOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "moduleId" | "order" | "type" | "videoUrl" | "duration" | "titleFr" | "titleEn" | "titleEs" | "contentFr" | "contentEn" | "contentEs", ExtArgs["result"]["lesson"]>
|
|
export type LessonInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
lessonProgress?: boolean | Lesson$lessonProgressArgs<ExtArgs>
|
|
_count?: boolean | LessonCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type LessonIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}
|
|
export type LessonIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $LessonPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Lesson"
|
|
objects: {
|
|
module: Prisma.$ModulePayload<ExtArgs>
|
|
lessonProgress: Prisma.$LessonProgressPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
moduleId: string
|
|
order: number
|
|
type: $Enums.LessonType
|
|
videoUrl: string | null
|
|
duration: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr: string | null
|
|
contentEn: string | null
|
|
contentEs: string | null
|
|
}, ExtArgs["result"]["lesson"]>
|
|
composites: {}
|
|
}
|
|
|
|
type LessonGetPayload<S extends boolean | null | undefined | LessonDefaultArgs> = $Result.GetResult<Prisma.$LessonPayload, S>
|
|
|
|
type LessonCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<LessonFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: LessonCountAggregateInputType | true
|
|
}
|
|
|
|
export interface LessonDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Lesson'], meta: { name: 'Lesson' } }
|
|
/**
|
|
* Find zero or one Lesson that matches the filter.
|
|
* @param {LessonFindUniqueArgs} args - Arguments to find a Lesson
|
|
* @example
|
|
* // Get one Lesson
|
|
* const lesson = await prisma.lesson.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends LessonFindUniqueArgs>(args: SelectSubset<T, LessonFindUniqueArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Lesson that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {LessonFindUniqueOrThrowArgs} args - Arguments to find a Lesson
|
|
* @example
|
|
* // Get one Lesson
|
|
* const lesson = await prisma.lesson.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends LessonFindUniqueOrThrowArgs>(args: SelectSubset<T, LessonFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Lesson 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 {LessonFindFirstArgs} args - Arguments to find a Lesson
|
|
* @example
|
|
* // Get one Lesson
|
|
* const lesson = await prisma.lesson.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends LessonFindFirstArgs>(args?: SelectSubset<T, LessonFindFirstArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Lesson 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 {LessonFindFirstOrThrowArgs} args - Arguments to find a Lesson
|
|
* @example
|
|
* // Get one Lesson
|
|
* const lesson = await prisma.lesson.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends LessonFindFirstOrThrowArgs>(args?: SelectSubset<T, LessonFindFirstOrThrowArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Lessons 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 {LessonFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Lessons
|
|
* const lessons = await prisma.lesson.findMany()
|
|
*
|
|
* // Get first 10 Lessons
|
|
* const lessons = await prisma.lesson.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const lessonWithIdOnly = await prisma.lesson.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends LessonFindManyArgs>(args?: SelectSubset<T, LessonFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Lesson.
|
|
* @param {LessonCreateArgs} args - Arguments to create a Lesson.
|
|
* @example
|
|
* // Create one Lesson
|
|
* const Lesson = await prisma.lesson.create({
|
|
* data: {
|
|
* // ... data to create a Lesson
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends LessonCreateArgs>(args: SelectSubset<T, LessonCreateArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Lessons.
|
|
* @param {LessonCreateManyArgs} args - Arguments to create many Lessons.
|
|
* @example
|
|
* // Create many Lessons
|
|
* const lesson = await prisma.lesson.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends LessonCreateManyArgs>(args?: SelectSubset<T, LessonCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Lessons and returns the data saved in the database.
|
|
* @param {LessonCreateManyAndReturnArgs} args - Arguments to create many Lessons.
|
|
* @example
|
|
* // Create many Lessons
|
|
* const lesson = await prisma.lesson.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Lessons and only return the `id`
|
|
* const lessonWithIdOnly = await prisma.lesson.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 LessonCreateManyAndReturnArgs>(args?: SelectSubset<T, LessonCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Lesson.
|
|
* @param {LessonDeleteArgs} args - Arguments to delete one Lesson.
|
|
* @example
|
|
* // Delete one Lesson
|
|
* const Lesson = await prisma.lesson.delete({
|
|
* where: {
|
|
* // ... filter to delete one Lesson
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends LessonDeleteArgs>(args: SelectSubset<T, LessonDeleteArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Lesson.
|
|
* @param {LessonUpdateArgs} args - Arguments to update one Lesson.
|
|
* @example
|
|
* // Update one Lesson
|
|
* const lesson = await prisma.lesson.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends LessonUpdateArgs>(args: SelectSubset<T, LessonUpdateArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Lessons.
|
|
* @param {LessonDeleteManyArgs} args - Arguments to filter Lessons to delete.
|
|
* @example
|
|
* // Delete a few Lessons
|
|
* const { count } = await prisma.lesson.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends LessonDeleteManyArgs>(args?: SelectSubset<T, LessonDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Lessons.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Lessons
|
|
* const lesson = await prisma.lesson.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends LessonUpdateManyArgs>(args: SelectSubset<T, LessonUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Lessons and returns the data updated in the database.
|
|
* @param {LessonUpdateManyAndReturnArgs} args - Arguments to update many Lessons.
|
|
* @example
|
|
* // Update many Lessons
|
|
* const lesson = await prisma.lesson.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Lessons and only return the `id`
|
|
* const lessonWithIdOnly = await prisma.lesson.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 LessonUpdateManyAndReturnArgs>(args: SelectSubset<T, LessonUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Lesson.
|
|
* @param {LessonUpsertArgs} args - Arguments to update or create a Lesson.
|
|
* @example
|
|
* // Update or create a Lesson
|
|
* const lesson = await prisma.lesson.upsert({
|
|
* create: {
|
|
* // ... data to create a Lesson
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Lesson we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends LessonUpsertArgs>(args: SelectSubset<T, LessonUpsertArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Lessons.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonCountArgs} args - Arguments to filter Lessons to count.
|
|
* @example
|
|
* // Count the number of Lessons
|
|
* const count = await prisma.lesson.count({
|
|
* where: {
|
|
* // ... the filter for the Lessons we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends LessonCountArgs>(
|
|
args?: Subset<T, LessonCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], LessonCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Lesson.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonAggregateArgs} 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 LessonAggregateArgs>(args: Subset<T, LessonAggregateArgs>): Prisma.PrismaPromise<GetLessonAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Lesson.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonGroupByArgs} 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 LessonGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: LessonGroupByArgs['orderBy'] }
|
|
: { orderBy?: LessonGroupByArgs['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, LessonGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLessonGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Lesson model
|
|
*/
|
|
readonly fields: LessonFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Lesson.
|
|
* 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__LessonClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
module<T extends ModuleDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ModuleDefaultArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
lessonProgress<T extends Lesson$lessonProgressArgs<ExtArgs> = {}>(args?: Subset<T, Lesson$lessonProgressArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonProgressPayload<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 Lesson model
|
|
*/
|
|
interface LessonFieldRefs {
|
|
readonly id: FieldRef<"Lesson", 'String'>
|
|
readonly moduleId: FieldRef<"Lesson", 'String'>
|
|
readonly order: FieldRef<"Lesson", 'Int'>
|
|
readonly type: FieldRef<"Lesson", 'LessonType'>
|
|
readonly videoUrl: FieldRef<"Lesson", 'String'>
|
|
readonly duration: FieldRef<"Lesson", 'Int'>
|
|
readonly titleFr: FieldRef<"Lesson", 'String'>
|
|
readonly titleEn: FieldRef<"Lesson", 'String'>
|
|
readonly titleEs: FieldRef<"Lesson", 'String'>
|
|
readonly contentFr: FieldRef<"Lesson", 'String'>
|
|
readonly contentEn: FieldRef<"Lesson", 'String'>
|
|
readonly contentEs: FieldRef<"Lesson", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Lesson findUnique
|
|
*/
|
|
export type LessonFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Lesson to fetch.
|
|
*/
|
|
where: LessonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Lesson findUniqueOrThrow
|
|
*/
|
|
export type LessonFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Lesson to fetch.
|
|
*/
|
|
where: LessonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Lesson findFirst
|
|
*/
|
|
export type LessonFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Lesson to fetch.
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Lessons to fetch.
|
|
*/
|
|
orderBy?: LessonOrderByWithRelationInput | LessonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Lessons.
|
|
*/
|
|
cursor?: LessonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Lessons from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Lessons.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Lessons.
|
|
*/
|
|
distinct?: LessonScalarFieldEnum | LessonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Lesson findFirstOrThrow
|
|
*/
|
|
export type LessonFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Lesson to fetch.
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Lessons to fetch.
|
|
*/
|
|
orderBy?: LessonOrderByWithRelationInput | LessonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Lessons.
|
|
*/
|
|
cursor?: LessonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Lessons from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Lessons.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Lessons.
|
|
*/
|
|
distinct?: LessonScalarFieldEnum | LessonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Lesson findMany
|
|
*/
|
|
export type LessonFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Lessons to fetch.
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Lessons to fetch.
|
|
*/
|
|
orderBy?: LessonOrderByWithRelationInput | LessonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Lessons.
|
|
*/
|
|
cursor?: LessonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Lessons from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Lessons.
|
|
*/
|
|
skip?: number
|
|
distinct?: LessonScalarFieldEnum | LessonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Lesson create
|
|
*/
|
|
export type LessonCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Lesson.
|
|
*/
|
|
data: XOR<LessonCreateInput, LessonUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Lesson createMany
|
|
*/
|
|
export type LessonCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Lessons.
|
|
*/
|
|
data: LessonCreateManyInput | LessonCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Lesson createManyAndReturn
|
|
*/
|
|
export type LessonCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Lessons.
|
|
*/
|
|
data: LessonCreateManyInput | LessonCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Lesson update
|
|
*/
|
|
export type LessonUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Lesson.
|
|
*/
|
|
data: XOR<LessonUpdateInput, LessonUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Lesson to update.
|
|
*/
|
|
where: LessonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Lesson updateMany
|
|
*/
|
|
export type LessonUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Lessons.
|
|
*/
|
|
data: XOR<LessonUpdateManyMutationInput, LessonUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Lessons to update
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* Limit how many Lessons to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Lesson updateManyAndReturn
|
|
*/
|
|
export type LessonUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Lessons.
|
|
*/
|
|
data: XOR<LessonUpdateManyMutationInput, LessonUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Lessons to update
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* Limit how many Lessons to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Lesson upsert
|
|
*/
|
|
export type LessonUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Lesson to update in case it exists.
|
|
*/
|
|
where: LessonWhereUniqueInput
|
|
/**
|
|
* In case the Lesson found by the `where` argument doesn't exist, create a new Lesson with this data.
|
|
*/
|
|
create: XOR<LessonCreateInput, LessonUncheckedCreateInput>
|
|
/**
|
|
* In case the Lesson was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<LessonUpdateInput, LessonUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Lesson delete
|
|
*/
|
|
export type LessonDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Lesson to delete.
|
|
*/
|
|
where: LessonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Lesson deleteMany
|
|
*/
|
|
export type LessonDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Lessons to delete
|
|
*/
|
|
where?: LessonWhereInput
|
|
/**
|
|
* Limit how many Lessons to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Lesson.lessonProgress
|
|
*/
|
|
export type Lesson$lessonProgressArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
where?: LessonProgressWhereInput
|
|
orderBy?: LessonProgressOrderByWithRelationInput | LessonProgressOrderByWithRelationInput[]
|
|
cursor?: LessonProgressWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: LessonProgressScalarFieldEnum | LessonProgressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Lesson without action
|
|
*/
|
|
export type LessonDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Lesson
|
|
*/
|
|
select?: LessonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Lesson
|
|
*/
|
|
omit?: LessonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Quiz
|
|
*/
|
|
|
|
export type AggregateQuiz = {
|
|
_count: QuizCountAggregateOutputType | null
|
|
_avg: QuizAvgAggregateOutputType | null
|
|
_sum: QuizSumAggregateOutputType | null
|
|
_min: QuizMinAggregateOutputType | null
|
|
_max: QuizMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type QuizAvgAggregateOutputType = {
|
|
passMark: number | null
|
|
}
|
|
|
|
export type QuizSumAggregateOutputType = {
|
|
passMark: number | null
|
|
}
|
|
|
|
export type QuizMinAggregateOutputType = {
|
|
id: string | null
|
|
moduleId: string | null
|
|
passMark: number | null
|
|
}
|
|
|
|
export type QuizMaxAggregateOutputType = {
|
|
id: string | null
|
|
moduleId: string | null
|
|
passMark: number | null
|
|
}
|
|
|
|
export type QuizCountAggregateOutputType = {
|
|
id: number
|
|
moduleId: number
|
|
passMark: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type QuizAvgAggregateInputType = {
|
|
passMark?: true
|
|
}
|
|
|
|
export type QuizSumAggregateInputType = {
|
|
passMark?: true
|
|
}
|
|
|
|
export type QuizMinAggregateInputType = {
|
|
id?: true
|
|
moduleId?: true
|
|
passMark?: true
|
|
}
|
|
|
|
export type QuizMaxAggregateInputType = {
|
|
id?: true
|
|
moduleId?: true
|
|
passMark?: true
|
|
}
|
|
|
|
export type QuizCountAggregateInputType = {
|
|
id?: true
|
|
moduleId?: true
|
|
passMark?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type QuizAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Quiz to aggregate.
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Quizzes to fetch.
|
|
*/
|
|
orderBy?: QuizOrderByWithRelationInput | QuizOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: QuizWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Quizzes from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Quizzes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Quizzes
|
|
**/
|
|
_count?: true | QuizCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: QuizAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: QuizSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: QuizMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: QuizMaxAggregateInputType
|
|
}
|
|
|
|
export type GetQuizAggregateType<T extends QuizAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateQuiz]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateQuiz[P]>
|
|
: GetScalarType<T[P], AggregateQuiz[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type QuizGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: QuizWhereInput
|
|
orderBy?: QuizOrderByWithAggregationInput | QuizOrderByWithAggregationInput[]
|
|
by: QuizScalarFieldEnum[] | QuizScalarFieldEnum
|
|
having?: QuizScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: QuizCountAggregateInputType | true
|
|
_avg?: QuizAvgAggregateInputType
|
|
_sum?: QuizSumAggregateInputType
|
|
_min?: QuizMinAggregateInputType
|
|
_max?: QuizMaxAggregateInputType
|
|
}
|
|
|
|
export type QuizGroupByOutputType = {
|
|
id: string
|
|
moduleId: string
|
|
passMark: number
|
|
_count: QuizCountAggregateOutputType | null
|
|
_avg: QuizAvgAggregateOutputType | null
|
|
_sum: QuizSumAggregateOutputType | null
|
|
_min: QuizMinAggregateOutputType | null
|
|
_max: QuizMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetQuizGroupByPayload<T extends QuizGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<QuizGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof QuizGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], QuizGroupByOutputType[P]>
|
|
: GetScalarType<T[P], QuizGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type QuizSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
passMark?: boolean
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
questions?: boolean | Quiz$questionsArgs<ExtArgs>
|
|
attempts?: boolean | Quiz$attemptsArgs<ExtArgs>
|
|
_count?: boolean | QuizCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["quiz"]>
|
|
|
|
export type QuizSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
passMark?: boolean
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["quiz"]>
|
|
|
|
export type QuizSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
passMark?: boolean
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["quiz"]>
|
|
|
|
export type QuizSelectScalar = {
|
|
id?: boolean
|
|
moduleId?: boolean
|
|
passMark?: boolean
|
|
}
|
|
|
|
export type QuizOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "moduleId" | "passMark", ExtArgs["result"]["quiz"]>
|
|
export type QuizInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
questions?: boolean | Quiz$questionsArgs<ExtArgs>
|
|
attempts?: boolean | Quiz$attemptsArgs<ExtArgs>
|
|
_count?: boolean | QuizCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type QuizIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}
|
|
export type QuizIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
module?: boolean | ModuleDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $QuizPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Quiz"
|
|
objects: {
|
|
module: Prisma.$ModulePayload<ExtArgs>
|
|
questions: Prisma.$QuestionPayload<ExtArgs>[]
|
|
attempts: Prisma.$QuizAttemptPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
moduleId: string
|
|
passMark: number
|
|
}, ExtArgs["result"]["quiz"]>
|
|
composites: {}
|
|
}
|
|
|
|
type QuizGetPayload<S extends boolean | null | undefined | QuizDefaultArgs> = $Result.GetResult<Prisma.$QuizPayload, S>
|
|
|
|
type QuizCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<QuizFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: QuizCountAggregateInputType | true
|
|
}
|
|
|
|
export interface QuizDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Quiz'], meta: { name: 'Quiz' } }
|
|
/**
|
|
* Find zero or one Quiz that matches the filter.
|
|
* @param {QuizFindUniqueArgs} args - Arguments to find a Quiz
|
|
* @example
|
|
* // Get one Quiz
|
|
* const quiz = await prisma.quiz.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends QuizFindUniqueArgs>(args: SelectSubset<T, QuizFindUniqueArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Quiz that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {QuizFindUniqueOrThrowArgs} args - Arguments to find a Quiz
|
|
* @example
|
|
* // Get one Quiz
|
|
* const quiz = await prisma.quiz.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends QuizFindUniqueOrThrowArgs>(args: SelectSubset<T, QuizFindUniqueOrThrowArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Quiz 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 {QuizFindFirstArgs} args - Arguments to find a Quiz
|
|
* @example
|
|
* // Get one Quiz
|
|
* const quiz = await prisma.quiz.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends QuizFindFirstArgs>(args?: SelectSubset<T, QuizFindFirstArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Quiz 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 {QuizFindFirstOrThrowArgs} args - Arguments to find a Quiz
|
|
* @example
|
|
* // Get one Quiz
|
|
* const quiz = await prisma.quiz.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends QuizFindFirstOrThrowArgs>(args?: SelectSubset<T, QuizFindFirstOrThrowArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Quizzes 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 {QuizFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Quizzes
|
|
* const quizzes = await prisma.quiz.findMany()
|
|
*
|
|
* // Get first 10 Quizzes
|
|
* const quizzes = await prisma.quiz.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const quizWithIdOnly = await prisma.quiz.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends QuizFindManyArgs>(args?: SelectSubset<T, QuizFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Quiz.
|
|
* @param {QuizCreateArgs} args - Arguments to create a Quiz.
|
|
* @example
|
|
* // Create one Quiz
|
|
* const Quiz = await prisma.quiz.create({
|
|
* data: {
|
|
* // ... data to create a Quiz
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends QuizCreateArgs>(args: SelectSubset<T, QuizCreateArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Quizzes.
|
|
* @param {QuizCreateManyArgs} args - Arguments to create many Quizzes.
|
|
* @example
|
|
* // Create many Quizzes
|
|
* const quiz = await prisma.quiz.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends QuizCreateManyArgs>(args?: SelectSubset<T, QuizCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Quizzes and returns the data saved in the database.
|
|
* @param {QuizCreateManyAndReturnArgs} args - Arguments to create many Quizzes.
|
|
* @example
|
|
* // Create many Quizzes
|
|
* const quiz = await prisma.quiz.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Quizzes and only return the `id`
|
|
* const quizWithIdOnly = await prisma.quiz.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 QuizCreateManyAndReturnArgs>(args?: SelectSubset<T, QuizCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Quiz.
|
|
* @param {QuizDeleteArgs} args - Arguments to delete one Quiz.
|
|
* @example
|
|
* // Delete one Quiz
|
|
* const Quiz = await prisma.quiz.delete({
|
|
* where: {
|
|
* // ... filter to delete one Quiz
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends QuizDeleteArgs>(args: SelectSubset<T, QuizDeleteArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Quiz.
|
|
* @param {QuizUpdateArgs} args - Arguments to update one Quiz.
|
|
* @example
|
|
* // Update one Quiz
|
|
* const quiz = await prisma.quiz.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends QuizUpdateArgs>(args: SelectSubset<T, QuizUpdateArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Quizzes.
|
|
* @param {QuizDeleteManyArgs} args - Arguments to filter Quizzes to delete.
|
|
* @example
|
|
* // Delete a few Quizzes
|
|
* const { count } = await prisma.quiz.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends QuizDeleteManyArgs>(args?: SelectSubset<T, QuizDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Quizzes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Quizzes
|
|
* const quiz = await prisma.quiz.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends QuizUpdateManyArgs>(args: SelectSubset<T, QuizUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Quizzes and returns the data updated in the database.
|
|
* @param {QuizUpdateManyAndReturnArgs} args - Arguments to update many Quizzes.
|
|
* @example
|
|
* // Update many Quizzes
|
|
* const quiz = await prisma.quiz.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Quizzes and only return the `id`
|
|
* const quizWithIdOnly = await prisma.quiz.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 QuizUpdateManyAndReturnArgs>(args: SelectSubset<T, QuizUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Quiz.
|
|
* @param {QuizUpsertArgs} args - Arguments to update or create a Quiz.
|
|
* @example
|
|
* // Update or create a Quiz
|
|
* const quiz = await prisma.quiz.upsert({
|
|
* create: {
|
|
* // ... data to create a Quiz
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Quiz we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends QuizUpsertArgs>(args: SelectSubset<T, QuizUpsertArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Quizzes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizCountArgs} args - Arguments to filter Quizzes to count.
|
|
* @example
|
|
* // Count the number of Quizzes
|
|
* const count = await prisma.quiz.count({
|
|
* where: {
|
|
* // ... the filter for the Quizzes we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends QuizCountArgs>(
|
|
args?: Subset<T, QuizCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], QuizCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Quiz.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizAggregateArgs} 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 QuizAggregateArgs>(args: Subset<T, QuizAggregateArgs>): Prisma.PrismaPromise<GetQuizAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Quiz.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizGroupByArgs} 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 QuizGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: QuizGroupByArgs['orderBy'] }
|
|
: { orderBy?: QuizGroupByArgs['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, QuizGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuizGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Quiz model
|
|
*/
|
|
readonly fields: QuizFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Quiz.
|
|
* 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__QuizClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
module<T extends ModuleDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ModuleDefaultArgs<ExtArgs>>): Prisma__ModuleClient<$Result.GetResult<Prisma.$ModulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
questions<T extends Quiz$questionsArgs<ExtArgs> = {}>(args?: Subset<T, Quiz$questionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
attempts<T extends Quiz$attemptsArgs<ExtArgs> = {}>(args?: Subset<T, Quiz$attemptsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizAttemptPayload<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 Quiz model
|
|
*/
|
|
interface QuizFieldRefs {
|
|
readonly id: FieldRef<"Quiz", 'String'>
|
|
readonly moduleId: FieldRef<"Quiz", 'String'>
|
|
readonly passMark: FieldRef<"Quiz", 'Int'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Quiz findUnique
|
|
*/
|
|
export type QuizFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Quiz to fetch.
|
|
*/
|
|
where: QuizWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Quiz findUniqueOrThrow
|
|
*/
|
|
export type QuizFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Quiz to fetch.
|
|
*/
|
|
where: QuizWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Quiz findFirst
|
|
*/
|
|
export type QuizFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Quiz to fetch.
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Quizzes to fetch.
|
|
*/
|
|
orderBy?: QuizOrderByWithRelationInput | QuizOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Quizzes.
|
|
*/
|
|
cursor?: QuizWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Quizzes from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Quizzes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Quizzes.
|
|
*/
|
|
distinct?: QuizScalarFieldEnum | QuizScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Quiz findFirstOrThrow
|
|
*/
|
|
export type QuizFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Quiz to fetch.
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Quizzes to fetch.
|
|
*/
|
|
orderBy?: QuizOrderByWithRelationInput | QuizOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Quizzes.
|
|
*/
|
|
cursor?: QuizWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Quizzes from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Quizzes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Quizzes.
|
|
*/
|
|
distinct?: QuizScalarFieldEnum | QuizScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Quiz findMany
|
|
*/
|
|
export type QuizFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Quizzes to fetch.
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Quizzes to fetch.
|
|
*/
|
|
orderBy?: QuizOrderByWithRelationInput | QuizOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Quizzes.
|
|
*/
|
|
cursor?: QuizWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Quizzes from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Quizzes.
|
|
*/
|
|
skip?: number
|
|
distinct?: QuizScalarFieldEnum | QuizScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Quiz create
|
|
*/
|
|
export type QuizCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Quiz.
|
|
*/
|
|
data: XOR<QuizCreateInput, QuizUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Quiz createMany
|
|
*/
|
|
export type QuizCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Quizzes.
|
|
*/
|
|
data: QuizCreateManyInput | QuizCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Quiz createManyAndReturn
|
|
*/
|
|
export type QuizCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Quizzes.
|
|
*/
|
|
data: QuizCreateManyInput | QuizCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Quiz update
|
|
*/
|
|
export type QuizUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Quiz.
|
|
*/
|
|
data: XOR<QuizUpdateInput, QuizUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Quiz to update.
|
|
*/
|
|
where: QuizWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Quiz updateMany
|
|
*/
|
|
export type QuizUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Quizzes.
|
|
*/
|
|
data: XOR<QuizUpdateManyMutationInput, QuizUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Quizzes to update
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* Limit how many Quizzes to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Quiz updateManyAndReturn
|
|
*/
|
|
export type QuizUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Quizzes.
|
|
*/
|
|
data: XOR<QuizUpdateManyMutationInput, QuizUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Quizzes to update
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* Limit how many Quizzes to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Quiz upsert
|
|
*/
|
|
export type QuizUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Quiz to update in case it exists.
|
|
*/
|
|
where: QuizWhereUniqueInput
|
|
/**
|
|
* In case the Quiz found by the `where` argument doesn't exist, create a new Quiz with this data.
|
|
*/
|
|
create: XOR<QuizCreateInput, QuizUncheckedCreateInput>
|
|
/**
|
|
* In case the Quiz was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<QuizUpdateInput, QuizUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Quiz delete
|
|
*/
|
|
export type QuizDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Quiz to delete.
|
|
*/
|
|
where: QuizWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Quiz deleteMany
|
|
*/
|
|
export type QuizDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Quizzes to delete
|
|
*/
|
|
where?: QuizWhereInput
|
|
/**
|
|
* Limit how many Quizzes to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Quiz.questions
|
|
*/
|
|
export type Quiz$questionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
where?: QuestionWhereInput
|
|
orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
|
|
cursor?: QuestionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: QuestionScalarFieldEnum | QuestionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Quiz.attempts
|
|
*/
|
|
export type Quiz$attemptsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
where?: QuizAttemptWhereInput
|
|
orderBy?: QuizAttemptOrderByWithRelationInput | QuizAttemptOrderByWithRelationInput[]
|
|
cursor?: QuizAttemptWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: QuizAttemptScalarFieldEnum | QuizAttemptScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Quiz without action
|
|
*/
|
|
export type QuizDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Quiz
|
|
*/
|
|
select?: QuizSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Quiz
|
|
*/
|
|
omit?: QuizOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Question
|
|
*/
|
|
|
|
export type AggregateQuestion = {
|
|
_count: QuestionCountAggregateOutputType | null
|
|
_avg: QuestionAvgAggregateOutputType | null
|
|
_sum: QuestionSumAggregateOutputType | null
|
|
_min: QuestionMinAggregateOutputType | null
|
|
_max: QuestionMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type QuestionAvgAggregateOutputType = {
|
|
order: number | null
|
|
correctIndex: number | null
|
|
}
|
|
|
|
export type QuestionSumAggregateOutputType = {
|
|
order: number | null
|
|
correctIndex: number | null
|
|
}
|
|
|
|
export type QuestionMinAggregateOutputType = {
|
|
id: string | null
|
|
quizId: string | null
|
|
order: number | null
|
|
textFr: string | null
|
|
textEn: string | null
|
|
textEs: string | null
|
|
correctIndex: number | null
|
|
}
|
|
|
|
export type QuestionMaxAggregateOutputType = {
|
|
id: string | null
|
|
quizId: string | null
|
|
order: number | null
|
|
textFr: string | null
|
|
textEn: string | null
|
|
textEs: string | null
|
|
correctIndex: number | null
|
|
}
|
|
|
|
export type QuestionCountAggregateOutputType = {
|
|
id: number
|
|
quizId: number
|
|
order: number
|
|
textFr: number
|
|
textEn: number
|
|
textEs: number
|
|
optionsFr: number
|
|
optionsEn: number
|
|
optionsEs: number
|
|
correctIndex: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type QuestionAvgAggregateInputType = {
|
|
order?: true
|
|
correctIndex?: true
|
|
}
|
|
|
|
export type QuestionSumAggregateInputType = {
|
|
order?: true
|
|
correctIndex?: true
|
|
}
|
|
|
|
export type QuestionMinAggregateInputType = {
|
|
id?: true
|
|
quizId?: true
|
|
order?: true
|
|
textFr?: true
|
|
textEn?: true
|
|
textEs?: true
|
|
correctIndex?: true
|
|
}
|
|
|
|
export type QuestionMaxAggregateInputType = {
|
|
id?: true
|
|
quizId?: true
|
|
order?: true
|
|
textFr?: true
|
|
textEn?: true
|
|
textEs?: true
|
|
correctIndex?: true
|
|
}
|
|
|
|
export type QuestionCountAggregateInputType = {
|
|
id?: true
|
|
quizId?: true
|
|
order?: true
|
|
textFr?: true
|
|
textEn?: true
|
|
textEs?: true
|
|
optionsFr?: true
|
|
optionsEn?: true
|
|
optionsEs?: true
|
|
correctIndex?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type QuestionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Question to aggregate.
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Questions to fetch.
|
|
*/
|
|
orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: QuestionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Questions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Questions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Questions
|
|
**/
|
|
_count?: true | QuestionCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: QuestionAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: QuestionSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: QuestionMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: QuestionMaxAggregateInputType
|
|
}
|
|
|
|
export type GetQuestionAggregateType<T extends QuestionAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateQuestion]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateQuestion[P]>
|
|
: GetScalarType<T[P], AggregateQuestion[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type QuestionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: QuestionWhereInput
|
|
orderBy?: QuestionOrderByWithAggregationInput | QuestionOrderByWithAggregationInput[]
|
|
by: QuestionScalarFieldEnum[] | QuestionScalarFieldEnum
|
|
having?: QuestionScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: QuestionCountAggregateInputType | true
|
|
_avg?: QuestionAvgAggregateInputType
|
|
_sum?: QuestionSumAggregateInputType
|
|
_min?: QuestionMinAggregateInputType
|
|
_max?: QuestionMaxAggregateInputType
|
|
}
|
|
|
|
export type QuestionGroupByOutputType = {
|
|
id: string
|
|
quizId: string
|
|
order: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr: string[]
|
|
optionsEn: string[]
|
|
optionsEs: string[]
|
|
correctIndex: number
|
|
_count: QuestionCountAggregateOutputType | null
|
|
_avg: QuestionAvgAggregateOutputType | null
|
|
_sum: QuestionSumAggregateOutputType | null
|
|
_min: QuestionMinAggregateOutputType | null
|
|
_max: QuestionMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetQuestionGroupByPayload<T extends QuestionGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<QuestionGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof QuestionGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], QuestionGroupByOutputType[P]>
|
|
: GetScalarType<T[P], QuestionGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type QuestionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
quizId?: boolean
|
|
order?: boolean
|
|
textFr?: boolean
|
|
textEn?: boolean
|
|
textEs?: boolean
|
|
optionsFr?: boolean
|
|
optionsEn?: boolean
|
|
optionsEs?: boolean
|
|
correctIndex?: boolean
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["question"]>
|
|
|
|
export type QuestionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
quizId?: boolean
|
|
order?: boolean
|
|
textFr?: boolean
|
|
textEn?: boolean
|
|
textEs?: boolean
|
|
optionsFr?: boolean
|
|
optionsEn?: boolean
|
|
optionsEs?: boolean
|
|
correctIndex?: boolean
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["question"]>
|
|
|
|
export type QuestionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
quizId?: boolean
|
|
order?: boolean
|
|
textFr?: boolean
|
|
textEn?: boolean
|
|
textEs?: boolean
|
|
optionsFr?: boolean
|
|
optionsEn?: boolean
|
|
optionsEs?: boolean
|
|
correctIndex?: boolean
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["question"]>
|
|
|
|
export type QuestionSelectScalar = {
|
|
id?: boolean
|
|
quizId?: boolean
|
|
order?: boolean
|
|
textFr?: boolean
|
|
textEn?: boolean
|
|
textEs?: boolean
|
|
optionsFr?: boolean
|
|
optionsEn?: boolean
|
|
optionsEs?: boolean
|
|
correctIndex?: boolean
|
|
}
|
|
|
|
export type QuestionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "quizId" | "order" | "textFr" | "textEn" | "textEs" | "optionsFr" | "optionsEn" | "optionsEs" | "correctIndex", ExtArgs["result"]["question"]>
|
|
export type QuestionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}
|
|
export type QuestionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}
|
|
export type QuestionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $QuestionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Question"
|
|
objects: {
|
|
quiz: Prisma.$QuizPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
quizId: string
|
|
order: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr: string[]
|
|
optionsEn: string[]
|
|
optionsEs: string[]
|
|
correctIndex: number
|
|
}, ExtArgs["result"]["question"]>
|
|
composites: {}
|
|
}
|
|
|
|
type QuestionGetPayload<S extends boolean | null | undefined | QuestionDefaultArgs> = $Result.GetResult<Prisma.$QuestionPayload, S>
|
|
|
|
type QuestionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<QuestionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: QuestionCountAggregateInputType | true
|
|
}
|
|
|
|
export interface QuestionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Question'], meta: { name: 'Question' } }
|
|
/**
|
|
* Find zero or one Question that matches the filter.
|
|
* @param {QuestionFindUniqueArgs} args - Arguments to find a Question
|
|
* @example
|
|
* // Get one Question
|
|
* const question = await prisma.question.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends QuestionFindUniqueArgs>(args: SelectSubset<T, QuestionFindUniqueArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Question that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {QuestionFindUniqueOrThrowArgs} args - Arguments to find a Question
|
|
* @example
|
|
* // Get one Question
|
|
* const question = await prisma.question.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends QuestionFindUniqueOrThrowArgs>(args: SelectSubset<T, QuestionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Question 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 {QuestionFindFirstArgs} args - Arguments to find a Question
|
|
* @example
|
|
* // Get one Question
|
|
* const question = await prisma.question.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends QuestionFindFirstArgs>(args?: SelectSubset<T, QuestionFindFirstArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Question 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 {QuestionFindFirstOrThrowArgs} args - Arguments to find a Question
|
|
* @example
|
|
* // Get one Question
|
|
* const question = await prisma.question.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends QuestionFindFirstOrThrowArgs>(args?: SelectSubset<T, QuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Questions 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 {QuestionFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Questions
|
|
* const questions = await prisma.question.findMany()
|
|
*
|
|
* // Get first 10 Questions
|
|
* const questions = await prisma.question.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const questionWithIdOnly = await prisma.question.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends QuestionFindManyArgs>(args?: SelectSubset<T, QuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Question.
|
|
* @param {QuestionCreateArgs} args - Arguments to create a Question.
|
|
* @example
|
|
* // Create one Question
|
|
* const Question = await prisma.question.create({
|
|
* data: {
|
|
* // ... data to create a Question
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends QuestionCreateArgs>(args: SelectSubset<T, QuestionCreateArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Questions.
|
|
* @param {QuestionCreateManyArgs} args - Arguments to create many Questions.
|
|
* @example
|
|
* // Create many Questions
|
|
* const question = await prisma.question.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends QuestionCreateManyArgs>(args?: SelectSubset<T, QuestionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Questions and returns the data saved in the database.
|
|
* @param {QuestionCreateManyAndReturnArgs} args - Arguments to create many Questions.
|
|
* @example
|
|
* // Create many Questions
|
|
* const question = await prisma.question.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Questions and only return the `id`
|
|
* const questionWithIdOnly = await prisma.question.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 QuestionCreateManyAndReturnArgs>(args?: SelectSubset<T, QuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Question.
|
|
* @param {QuestionDeleteArgs} args - Arguments to delete one Question.
|
|
* @example
|
|
* // Delete one Question
|
|
* const Question = await prisma.question.delete({
|
|
* where: {
|
|
* // ... filter to delete one Question
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends QuestionDeleteArgs>(args: SelectSubset<T, QuestionDeleteArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Question.
|
|
* @param {QuestionUpdateArgs} args - Arguments to update one Question.
|
|
* @example
|
|
* // Update one Question
|
|
* const question = await prisma.question.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends QuestionUpdateArgs>(args: SelectSubset<T, QuestionUpdateArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Questions.
|
|
* @param {QuestionDeleteManyArgs} args - Arguments to filter Questions to delete.
|
|
* @example
|
|
* // Delete a few Questions
|
|
* const { count } = await prisma.question.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends QuestionDeleteManyArgs>(args?: SelectSubset<T, QuestionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Questions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuestionUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Questions
|
|
* const question = await prisma.question.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends QuestionUpdateManyArgs>(args: SelectSubset<T, QuestionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Questions and returns the data updated in the database.
|
|
* @param {QuestionUpdateManyAndReturnArgs} args - Arguments to update many Questions.
|
|
* @example
|
|
* // Update many Questions
|
|
* const question = await prisma.question.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Questions and only return the `id`
|
|
* const questionWithIdOnly = await prisma.question.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 QuestionUpdateManyAndReturnArgs>(args: SelectSubset<T, QuestionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Question.
|
|
* @param {QuestionUpsertArgs} args - Arguments to update or create a Question.
|
|
* @example
|
|
* // Update or create a Question
|
|
* const question = await prisma.question.upsert({
|
|
* create: {
|
|
* // ... data to create a Question
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Question we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends QuestionUpsertArgs>(args: SelectSubset<T, QuestionUpsertArgs<ExtArgs>>): Prisma__QuestionClient<$Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Questions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuestionCountArgs} args - Arguments to filter Questions to count.
|
|
* @example
|
|
* // Count the number of Questions
|
|
* const count = await prisma.question.count({
|
|
* where: {
|
|
* // ... the filter for the Questions we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends QuestionCountArgs>(
|
|
args?: Subset<T, QuestionCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], QuestionCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Question.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuestionAggregateArgs} 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 QuestionAggregateArgs>(args: Subset<T, QuestionAggregateArgs>): Prisma.PrismaPromise<GetQuestionAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Question.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuestionGroupByArgs} 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 QuestionGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: QuestionGroupByArgs['orderBy'] }
|
|
: { orderBy?: QuestionGroupByArgs['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, QuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Question model
|
|
*/
|
|
readonly fields: QuestionFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Question.
|
|
* 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__QuestionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
quiz<T extends QuizDefaultArgs<ExtArgs> = {}>(args?: Subset<T, QuizDefaultArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<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 Question model
|
|
*/
|
|
interface QuestionFieldRefs {
|
|
readonly id: FieldRef<"Question", 'String'>
|
|
readonly quizId: FieldRef<"Question", 'String'>
|
|
readonly order: FieldRef<"Question", 'Int'>
|
|
readonly textFr: FieldRef<"Question", 'String'>
|
|
readonly textEn: FieldRef<"Question", 'String'>
|
|
readonly textEs: FieldRef<"Question", 'String'>
|
|
readonly optionsFr: FieldRef<"Question", 'String[]'>
|
|
readonly optionsEn: FieldRef<"Question", 'String[]'>
|
|
readonly optionsEs: FieldRef<"Question", 'String[]'>
|
|
readonly correctIndex: FieldRef<"Question", 'Int'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Question findUnique
|
|
*/
|
|
export type QuestionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Question to fetch.
|
|
*/
|
|
where: QuestionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Question findUniqueOrThrow
|
|
*/
|
|
export type QuestionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Question to fetch.
|
|
*/
|
|
where: QuestionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Question findFirst
|
|
*/
|
|
export type QuestionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Question to fetch.
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Questions to fetch.
|
|
*/
|
|
orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Questions.
|
|
*/
|
|
cursor?: QuestionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Questions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Questions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Questions.
|
|
*/
|
|
distinct?: QuestionScalarFieldEnum | QuestionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Question findFirstOrThrow
|
|
*/
|
|
export type QuestionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Question to fetch.
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Questions to fetch.
|
|
*/
|
|
orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Questions.
|
|
*/
|
|
cursor?: QuestionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Questions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Questions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Questions.
|
|
*/
|
|
distinct?: QuestionScalarFieldEnum | QuestionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Question findMany
|
|
*/
|
|
export type QuestionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Questions to fetch.
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Questions to fetch.
|
|
*/
|
|
orderBy?: QuestionOrderByWithRelationInput | QuestionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Questions.
|
|
*/
|
|
cursor?: QuestionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Questions from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Questions.
|
|
*/
|
|
skip?: number
|
|
distinct?: QuestionScalarFieldEnum | QuestionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Question create
|
|
*/
|
|
export type QuestionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Question.
|
|
*/
|
|
data: XOR<QuestionCreateInput, QuestionUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Question createMany
|
|
*/
|
|
export type QuestionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Questions.
|
|
*/
|
|
data: QuestionCreateManyInput | QuestionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Question createManyAndReturn
|
|
*/
|
|
export type QuestionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Questions.
|
|
*/
|
|
data: QuestionCreateManyInput | QuestionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Question update
|
|
*/
|
|
export type QuestionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Question.
|
|
*/
|
|
data: XOR<QuestionUpdateInput, QuestionUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Question to update.
|
|
*/
|
|
where: QuestionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Question updateMany
|
|
*/
|
|
export type QuestionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Questions.
|
|
*/
|
|
data: XOR<QuestionUpdateManyMutationInput, QuestionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Questions to update
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* Limit how many Questions to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Question updateManyAndReturn
|
|
*/
|
|
export type QuestionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Questions.
|
|
*/
|
|
data: XOR<QuestionUpdateManyMutationInput, QuestionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Questions to update
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* Limit how many Questions to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Question upsert
|
|
*/
|
|
export type QuestionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Question to update in case it exists.
|
|
*/
|
|
where: QuestionWhereUniqueInput
|
|
/**
|
|
* In case the Question found by the `where` argument doesn't exist, create a new Question with this data.
|
|
*/
|
|
create: XOR<QuestionCreateInput, QuestionUncheckedCreateInput>
|
|
/**
|
|
* In case the Question was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<QuestionUpdateInput, QuestionUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Question delete
|
|
*/
|
|
export type QuestionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Question to delete.
|
|
*/
|
|
where: QuestionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Question deleteMany
|
|
*/
|
|
export type QuestionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Questions to delete
|
|
*/
|
|
where?: QuestionWhereInput
|
|
/**
|
|
* Limit how many Questions to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Question without action
|
|
*/
|
|
export type QuestionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Question
|
|
*/
|
|
select?: QuestionSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Question
|
|
*/
|
|
omit?: QuestionOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuestionInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Enrollment
|
|
*/
|
|
|
|
export type AggregateEnrollment = {
|
|
_count: EnrollmentCountAggregateOutputType | null
|
|
_min: EnrollmentMinAggregateOutputType | null
|
|
_max: EnrollmentMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type EnrollmentMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
courseId: string | null
|
|
enrolledAt: Date | null
|
|
completedAt: Date | null
|
|
}
|
|
|
|
export type EnrollmentMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
courseId: string | null
|
|
enrolledAt: Date | null
|
|
completedAt: Date | null
|
|
}
|
|
|
|
export type EnrollmentCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
courseId: number
|
|
enrolledAt: number
|
|
completedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type EnrollmentMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
courseId?: true
|
|
enrolledAt?: true
|
|
completedAt?: true
|
|
}
|
|
|
|
export type EnrollmentMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
courseId?: true
|
|
enrolledAt?: true
|
|
completedAt?: true
|
|
}
|
|
|
|
export type EnrollmentCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
courseId?: true
|
|
enrolledAt?: true
|
|
completedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type EnrollmentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Enrollment to aggregate.
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Enrollments to fetch.
|
|
*/
|
|
orderBy?: EnrollmentOrderByWithRelationInput | EnrollmentOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: EnrollmentWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Enrollments from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Enrollments.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Enrollments
|
|
**/
|
|
_count?: true | EnrollmentCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: EnrollmentMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: EnrollmentMaxAggregateInputType
|
|
}
|
|
|
|
export type GetEnrollmentAggregateType<T extends EnrollmentAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateEnrollment]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateEnrollment[P]>
|
|
: GetScalarType<T[P], AggregateEnrollment[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type EnrollmentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: EnrollmentWhereInput
|
|
orderBy?: EnrollmentOrderByWithAggregationInput | EnrollmentOrderByWithAggregationInput[]
|
|
by: EnrollmentScalarFieldEnum[] | EnrollmentScalarFieldEnum
|
|
having?: EnrollmentScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: EnrollmentCountAggregateInputType | true
|
|
_min?: EnrollmentMinAggregateInputType
|
|
_max?: EnrollmentMaxAggregateInputType
|
|
}
|
|
|
|
export type EnrollmentGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
courseId: string
|
|
enrolledAt: Date
|
|
completedAt: Date | null
|
|
_count: EnrollmentCountAggregateOutputType | null
|
|
_min: EnrollmentMinAggregateOutputType | null
|
|
_max: EnrollmentMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetEnrollmentGroupByPayload<T extends EnrollmentGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<EnrollmentGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof EnrollmentGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], EnrollmentGroupByOutputType[P]>
|
|
: GetScalarType<T[P], EnrollmentGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type EnrollmentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
enrolledAt?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["enrollment"]>
|
|
|
|
export type EnrollmentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
enrolledAt?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["enrollment"]>
|
|
|
|
export type EnrollmentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
enrolledAt?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["enrollment"]>
|
|
|
|
export type EnrollmentSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
enrolledAt?: boolean
|
|
completedAt?: boolean
|
|
}
|
|
|
|
export type EnrollmentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "courseId" | "enrolledAt" | "completedAt", ExtArgs["result"]["enrollment"]>
|
|
export type EnrollmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
export type EnrollmentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
export type EnrollmentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $EnrollmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Enrollment"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
course: Prisma.$CoursePayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
courseId: string
|
|
enrolledAt: Date
|
|
completedAt: Date | null
|
|
}, ExtArgs["result"]["enrollment"]>
|
|
composites: {}
|
|
}
|
|
|
|
type EnrollmentGetPayload<S extends boolean | null | undefined | EnrollmentDefaultArgs> = $Result.GetResult<Prisma.$EnrollmentPayload, S>
|
|
|
|
type EnrollmentCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<EnrollmentFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: EnrollmentCountAggregateInputType | true
|
|
}
|
|
|
|
export interface EnrollmentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Enrollment'], meta: { name: 'Enrollment' } }
|
|
/**
|
|
* Find zero or one Enrollment that matches the filter.
|
|
* @param {EnrollmentFindUniqueArgs} args - Arguments to find a Enrollment
|
|
* @example
|
|
* // Get one Enrollment
|
|
* const enrollment = await prisma.enrollment.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends EnrollmentFindUniqueArgs>(args: SelectSubset<T, EnrollmentFindUniqueArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Enrollment that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {EnrollmentFindUniqueOrThrowArgs} args - Arguments to find a Enrollment
|
|
* @example
|
|
* // Get one Enrollment
|
|
* const enrollment = await prisma.enrollment.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends EnrollmentFindUniqueOrThrowArgs>(args: SelectSubset<T, EnrollmentFindUniqueOrThrowArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Enrollment 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 {EnrollmentFindFirstArgs} args - Arguments to find a Enrollment
|
|
* @example
|
|
* // Get one Enrollment
|
|
* const enrollment = await prisma.enrollment.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends EnrollmentFindFirstArgs>(args?: SelectSubset<T, EnrollmentFindFirstArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Enrollment 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 {EnrollmentFindFirstOrThrowArgs} args - Arguments to find a Enrollment
|
|
* @example
|
|
* // Get one Enrollment
|
|
* const enrollment = await prisma.enrollment.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends EnrollmentFindFirstOrThrowArgs>(args?: SelectSubset<T, EnrollmentFindFirstOrThrowArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Enrollments 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 {EnrollmentFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Enrollments
|
|
* const enrollments = await prisma.enrollment.findMany()
|
|
*
|
|
* // Get first 10 Enrollments
|
|
* const enrollments = await prisma.enrollment.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const enrollmentWithIdOnly = await prisma.enrollment.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends EnrollmentFindManyArgs>(args?: SelectSubset<T, EnrollmentFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Enrollment.
|
|
* @param {EnrollmentCreateArgs} args - Arguments to create a Enrollment.
|
|
* @example
|
|
* // Create one Enrollment
|
|
* const Enrollment = await prisma.enrollment.create({
|
|
* data: {
|
|
* // ... data to create a Enrollment
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends EnrollmentCreateArgs>(args: SelectSubset<T, EnrollmentCreateArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Enrollments.
|
|
* @param {EnrollmentCreateManyArgs} args - Arguments to create many Enrollments.
|
|
* @example
|
|
* // Create many Enrollments
|
|
* const enrollment = await prisma.enrollment.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends EnrollmentCreateManyArgs>(args?: SelectSubset<T, EnrollmentCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Enrollments and returns the data saved in the database.
|
|
* @param {EnrollmentCreateManyAndReturnArgs} args - Arguments to create many Enrollments.
|
|
* @example
|
|
* // Create many Enrollments
|
|
* const enrollment = await prisma.enrollment.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Enrollments and only return the `id`
|
|
* const enrollmentWithIdOnly = await prisma.enrollment.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 EnrollmentCreateManyAndReturnArgs>(args?: SelectSubset<T, EnrollmentCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Enrollment.
|
|
* @param {EnrollmentDeleteArgs} args - Arguments to delete one Enrollment.
|
|
* @example
|
|
* // Delete one Enrollment
|
|
* const Enrollment = await prisma.enrollment.delete({
|
|
* where: {
|
|
* // ... filter to delete one Enrollment
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends EnrollmentDeleteArgs>(args: SelectSubset<T, EnrollmentDeleteArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Enrollment.
|
|
* @param {EnrollmentUpdateArgs} args - Arguments to update one Enrollment.
|
|
* @example
|
|
* // Update one Enrollment
|
|
* const enrollment = await prisma.enrollment.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends EnrollmentUpdateArgs>(args: SelectSubset<T, EnrollmentUpdateArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Enrollments.
|
|
* @param {EnrollmentDeleteManyArgs} args - Arguments to filter Enrollments to delete.
|
|
* @example
|
|
* // Delete a few Enrollments
|
|
* const { count } = await prisma.enrollment.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends EnrollmentDeleteManyArgs>(args?: SelectSubset<T, EnrollmentDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Enrollments.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EnrollmentUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Enrollments
|
|
* const enrollment = await prisma.enrollment.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends EnrollmentUpdateManyArgs>(args: SelectSubset<T, EnrollmentUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Enrollments and returns the data updated in the database.
|
|
* @param {EnrollmentUpdateManyAndReturnArgs} args - Arguments to update many Enrollments.
|
|
* @example
|
|
* // Update many Enrollments
|
|
* const enrollment = await prisma.enrollment.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Enrollments and only return the `id`
|
|
* const enrollmentWithIdOnly = await prisma.enrollment.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 EnrollmentUpdateManyAndReturnArgs>(args: SelectSubset<T, EnrollmentUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Enrollment.
|
|
* @param {EnrollmentUpsertArgs} args - Arguments to update or create a Enrollment.
|
|
* @example
|
|
* // Update or create a Enrollment
|
|
* const enrollment = await prisma.enrollment.upsert({
|
|
* create: {
|
|
* // ... data to create a Enrollment
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Enrollment we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends EnrollmentUpsertArgs>(args: SelectSubset<T, EnrollmentUpsertArgs<ExtArgs>>): Prisma__EnrollmentClient<$Result.GetResult<Prisma.$EnrollmentPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Enrollments.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EnrollmentCountArgs} args - Arguments to filter Enrollments to count.
|
|
* @example
|
|
* // Count the number of Enrollments
|
|
* const count = await prisma.enrollment.count({
|
|
* where: {
|
|
* // ... the filter for the Enrollments we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends EnrollmentCountArgs>(
|
|
args?: Subset<T, EnrollmentCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], EnrollmentCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Enrollment.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EnrollmentAggregateArgs} 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 EnrollmentAggregateArgs>(args: Subset<T, EnrollmentAggregateArgs>): Prisma.PrismaPromise<GetEnrollmentAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Enrollment.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EnrollmentGroupByArgs} 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 EnrollmentGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: EnrollmentGroupByArgs['orderBy'] }
|
|
: { orderBy?: EnrollmentGroupByArgs['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, EnrollmentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetEnrollmentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Enrollment model
|
|
*/
|
|
readonly fields: EnrollmentFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Enrollment.
|
|
* 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__EnrollmentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
course<T extends CourseDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CourseDefaultArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<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 Enrollment model
|
|
*/
|
|
interface EnrollmentFieldRefs {
|
|
readonly id: FieldRef<"Enrollment", 'String'>
|
|
readonly userId: FieldRef<"Enrollment", 'String'>
|
|
readonly courseId: FieldRef<"Enrollment", 'String'>
|
|
readonly enrolledAt: FieldRef<"Enrollment", 'DateTime'>
|
|
readonly completedAt: FieldRef<"Enrollment", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Enrollment findUnique
|
|
*/
|
|
export type EnrollmentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Enrollment to fetch.
|
|
*/
|
|
where: EnrollmentWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Enrollment findUniqueOrThrow
|
|
*/
|
|
export type EnrollmentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Enrollment to fetch.
|
|
*/
|
|
where: EnrollmentWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Enrollment findFirst
|
|
*/
|
|
export type EnrollmentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Enrollment to fetch.
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Enrollments to fetch.
|
|
*/
|
|
orderBy?: EnrollmentOrderByWithRelationInput | EnrollmentOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Enrollments.
|
|
*/
|
|
cursor?: EnrollmentWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Enrollments from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Enrollments.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Enrollments.
|
|
*/
|
|
distinct?: EnrollmentScalarFieldEnum | EnrollmentScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Enrollment findFirstOrThrow
|
|
*/
|
|
export type EnrollmentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Enrollment to fetch.
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Enrollments to fetch.
|
|
*/
|
|
orderBy?: EnrollmentOrderByWithRelationInput | EnrollmentOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Enrollments.
|
|
*/
|
|
cursor?: EnrollmentWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Enrollments from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Enrollments.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Enrollments.
|
|
*/
|
|
distinct?: EnrollmentScalarFieldEnum | EnrollmentScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Enrollment findMany
|
|
*/
|
|
export type EnrollmentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Enrollments to fetch.
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Enrollments to fetch.
|
|
*/
|
|
orderBy?: EnrollmentOrderByWithRelationInput | EnrollmentOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Enrollments.
|
|
*/
|
|
cursor?: EnrollmentWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Enrollments from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Enrollments.
|
|
*/
|
|
skip?: number
|
|
distinct?: EnrollmentScalarFieldEnum | EnrollmentScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Enrollment create
|
|
*/
|
|
export type EnrollmentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Enrollment.
|
|
*/
|
|
data: XOR<EnrollmentCreateInput, EnrollmentUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Enrollment createMany
|
|
*/
|
|
export type EnrollmentCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Enrollments.
|
|
*/
|
|
data: EnrollmentCreateManyInput | EnrollmentCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Enrollment createManyAndReturn
|
|
*/
|
|
export type EnrollmentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Enrollments.
|
|
*/
|
|
data: EnrollmentCreateManyInput | EnrollmentCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Enrollment update
|
|
*/
|
|
export type EnrollmentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Enrollment.
|
|
*/
|
|
data: XOR<EnrollmentUpdateInput, EnrollmentUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Enrollment to update.
|
|
*/
|
|
where: EnrollmentWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Enrollment updateMany
|
|
*/
|
|
export type EnrollmentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Enrollments.
|
|
*/
|
|
data: XOR<EnrollmentUpdateManyMutationInput, EnrollmentUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Enrollments to update
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* Limit how many Enrollments to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Enrollment updateManyAndReturn
|
|
*/
|
|
export type EnrollmentUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Enrollments.
|
|
*/
|
|
data: XOR<EnrollmentUpdateManyMutationInput, EnrollmentUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Enrollments to update
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* Limit how many Enrollments to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Enrollment upsert
|
|
*/
|
|
export type EnrollmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Enrollment to update in case it exists.
|
|
*/
|
|
where: EnrollmentWhereUniqueInput
|
|
/**
|
|
* In case the Enrollment found by the `where` argument doesn't exist, create a new Enrollment with this data.
|
|
*/
|
|
create: XOR<EnrollmentCreateInput, EnrollmentUncheckedCreateInput>
|
|
/**
|
|
* In case the Enrollment was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<EnrollmentUpdateInput, EnrollmentUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Enrollment delete
|
|
*/
|
|
export type EnrollmentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Enrollment to delete.
|
|
*/
|
|
where: EnrollmentWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Enrollment deleteMany
|
|
*/
|
|
export type EnrollmentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Enrollments to delete
|
|
*/
|
|
where?: EnrollmentWhereInput
|
|
/**
|
|
* Limit how many Enrollments to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Enrollment without action
|
|
*/
|
|
export type EnrollmentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Enrollment
|
|
*/
|
|
select?: EnrollmentSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Enrollment
|
|
*/
|
|
omit?: EnrollmentOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: EnrollmentInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model LessonProgress
|
|
*/
|
|
|
|
export type AggregateLessonProgress = {
|
|
_count: LessonProgressCountAggregateOutputType | null
|
|
_min: LessonProgressMinAggregateOutputType | null
|
|
_max: LessonProgressMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type LessonProgressMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
lessonId: string | null
|
|
completedAt: Date | null
|
|
}
|
|
|
|
export type LessonProgressMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
lessonId: string | null
|
|
completedAt: Date | null
|
|
}
|
|
|
|
export type LessonProgressCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
lessonId: number
|
|
completedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type LessonProgressMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
lessonId?: true
|
|
completedAt?: true
|
|
}
|
|
|
|
export type LessonProgressMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
lessonId?: true
|
|
completedAt?: true
|
|
}
|
|
|
|
export type LessonProgressCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
lessonId?: true
|
|
completedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type LessonProgressAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which LessonProgress to aggregate.
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LessonProgresses to fetch.
|
|
*/
|
|
orderBy?: LessonProgressOrderByWithRelationInput | LessonProgressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: LessonProgressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LessonProgresses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LessonProgresses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned LessonProgresses
|
|
**/
|
|
_count?: true | LessonProgressCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: LessonProgressMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: LessonProgressMaxAggregateInputType
|
|
}
|
|
|
|
export type GetLessonProgressAggregateType<T extends LessonProgressAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateLessonProgress]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateLessonProgress[P]>
|
|
: GetScalarType<T[P], AggregateLessonProgress[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type LessonProgressGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: LessonProgressWhereInput
|
|
orderBy?: LessonProgressOrderByWithAggregationInput | LessonProgressOrderByWithAggregationInput[]
|
|
by: LessonProgressScalarFieldEnum[] | LessonProgressScalarFieldEnum
|
|
having?: LessonProgressScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: LessonProgressCountAggregateInputType | true
|
|
_min?: LessonProgressMinAggregateInputType
|
|
_max?: LessonProgressMaxAggregateInputType
|
|
}
|
|
|
|
export type LessonProgressGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
lessonId: string
|
|
completedAt: Date
|
|
_count: LessonProgressCountAggregateOutputType | null
|
|
_min: LessonProgressMinAggregateOutputType | null
|
|
_max: LessonProgressMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetLessonProgressGroupByPayload<T extends LessonProgressGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<LessonProgressGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof LessonProgressGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], LessonProgressGroupByOutputType[P]>
|
|
: GetScalarType<T[P], LessonProgressGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type LessonProgressSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
lessonId?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
lesson?: boolean | LessonDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["lessonProgress"]>
|
|
|
|
export type LessonProgressSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
lessonId?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
lesson?: boolean | LessonDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["lessonProgress"]>
|
|
|
|
export type LessonProgressSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
lessonId?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
lesson?: boolean | LessonDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["lessonProgress"]>
|
|
|
|
export type LessonProgressSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
lessonId?: boolean
|
|
completedAt?: boolean
|
|
}
|
|
|
|
export type LessonProgressOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "lessonId" | "completedAt", ExtArgs["result"]["lessonProgress"]>
|
|
export type LessonProgressInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
lesson?: boolean | LessonDefaultArgs<ExtArgs>
|
|
}
|
|
export type LessonProgressIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
lesson?: boolean | LessonDefaultArgs<ExtArgs>
|
|
}
|
|
export type LessonProgressIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
lesson?: boolean | LessonDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $LessonProgressPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "LessonProgress"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
lesson: Prisma.$LessonPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
lessonId: string
|
|
completedAt: Date
|
|
}, ExtArgs["result"]["lessonProgress"]>
|
|
composites: {}
|
|
}
|
|
|
|
type LessonProgressGetPayload<S extends boolean | null | undefined | LessonProgressDefaultArgs> = $Result.GetResult<Prisma.$LessonProgressPayload, S>
|
|
|
|
type LessonProgressCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<LessonProgressFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: LessonProgressCountAggregateInputType | true
|
|
}
|
|
|
|
export interface LessonProgressDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['LessonProgress'], meta: { name: 'LessonProgress' } }
|
|
/**
|
|
* Find zero or one LessonProgress that matches the filter.
|
|
* @param {LessonProgressFindUniqueArgs} args - Arguments to find a LessonProgress
|
|
* @example
|
|
* // Get one LessonProgress
|
|
* const lessonProgress = await prisma.lessonProgress.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends LessonProgressFindUniqueArgs>(args: SelectSubset<T, LessonProgressFindUniqueArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one LessonProgress that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {LessonProgressFindUniqueOrThrowArgs} args - Arguments to find a LessonProgress
|
|
* @example
|
|
* // Get one LessonProgress
|
|
* const lessonProgress = await prisma.lessonProgress.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends LessonProgressFindUniqueOrThrowArgs>(args: SelectSubset<T, LessonProgressFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first LessonProgress 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 {LessonProgressFindFirstArgs} args - Arguments to find a LessonProgress
|
|
* @example
|
|
* // Get one LessonProgress
|
|
* const lessonProgress = await prisma.lessonProgress.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends LessonProgressFindFirstArgs>(args?: SelectSubset<T, LessonProgressFindFirstArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first LessonProgress 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 {LessonProgressFindFirstOrThrowArgs} args - Arguments to find a LessonProgress
|
|
* @example
|
|
* // Get one LessonProgress
|
|
* const lessonProgress = await prisma.lessonProgress.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends LessonProgressFindFirstOrThrowArgs>(args?: SelectSubset<T, LessonProgressFindFirstOrThrowArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more LessonProgresses 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 {LessonProgressFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all LessonProgresses
|
|
* const lessonProgresses = await prisma.lessonProgress.findMany()
|
|
*
|
|
* // Get first 10 LessonProgresses
|
|
* const lessonProgresses = await prisma.lessonProgress.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const lessonProgressWithIdOnly = await prisma.lessonProgress.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends LessonProgressFindManyArgs>(args?: SelectSubset<T, LessonProgressFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a LessonProgress.
|
|
* @param {LessonProgressCreateArgs} args - Arguments to create a LessonProgress.
|
|
* @example
|
|
* // Create one LessonProgress
|
|
* const LessonProgress = await prisma.lessonProgress.create({
|
|
* data: {
|
|
* // ... data to create a LessonProgress
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends LessonProgressCreateArgs>(args: SelectSubset<T, LessonProgressCreateArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many LessonProgresses.
|
|
* @param {LessonProgressCreateManyArgs} args - Arguments to create many LessonProgresses.
|
|
* @example
|
|
* // Create many LessonProgresses
|
|
* const lessonProgress = await prisma.lessonProgress.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends LessonProgressCreateManyArgs>(args?: SelectSubset<T, LessonProgressCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many LessonProgresses and returns the data saved in the database.
|
|
* @param {LessonProgressCreateManyAndReturnArgs} args - Arguments to create many LessonProgresses.
|
|
* @example
|
|
* // Create many LessonProgresses
|
|
* const lessonProgress = await prisma.lessonProgress.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many LessonProgresses and only return the `id`
|
|
* const lessonProgressWithIdOnly = await prisma.lessonProgress.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 LessonProgressCreateManyAndReturnArgs>(args?: SelectSubset<T, LessonProgressCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a LessonProgress.
|
|
* @param {LessonProgressDeleteArgs} args - Arguments to delete one LessonProgress.
|
|
* @example
|
|
* // Delete one LessonProgress
|
|
* const LessonProgress = await prisma.lessonProgress.delete({
|
|
* where: {
|
|
* // ... filter to delete one LessonProgress
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends LessonProgressDeleteArgs>(args: SelectSubset<T, LessonProgressDeleteArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one LessonProgress.
|
|
* @param {LessonProgressUpdateArgs} args - Arguments to update one LessonProgress.
|
|
* @example
|
|
* // Update one LessonProgress
|
|
* const lessonProgress = await prisma.lessonProgress.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends LessonProgressUpdateArgs>(args: SelectSubset<T, LessonProgressUpdateArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more LessonProgresses.
|
|
* @param {LessonProgressDeleteManyArgs} args - Arguments to filter LessonProgresses to delete.
|
|
* @example
|
|
* // Delete a few LessonProgresses
|
|
* const { count } = await prisma.lessonProgress.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends LessonProgressDeleteManyArgs>(args?: SelectSubset<T, LessonProgressDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more LessonProgresses.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonProgressUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many LessonProgresses
|
|
* const lessonProgress = await prisma.lessonProgress.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends LessonProgressUpdateManyArgs>(args: SelectSubset<T, LessonProgressUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more LessonProgresses and returns the data updated in the database.
|
|
* @param {LessonProgressUpdateManyAndReturnArgs} args - Arguments to update many LessonProgresses.
|
|
* @example
|
|
* // Update many LessonProgresses
|
|
* const lessonProgress = await prisma.lessonProgress.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more LessonProgresses and only return the `id`
|
|
* const lessonProgressWithIdOnly = await prisma.lessonProgress.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 LessonProgressUpdateManyAndReturnArgs>(args: SelectSubset<T, LessonProgressUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one LessonProgress.
|
|
* @param {LessonProgressUpsertArgs} args - Arguments to update or create a LessonProgress.
|
|
* @example
|
|
* // Update or create a LessonProgress
|
|
* const lessonProgress = await prisma.lessonProgress.upsert({
|
|
* create: {
|
|
* // ... data to create a LessonProgress
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the LessonProgress we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends LessonProgressUpsertArgs>(args: SelectSubset<T, LessonProgressUpsertArgs<ExtArgs>>): Prisma__LessonProgressClient<$Result.GetResult<Prisma.$LessonProgressPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of LessonProgresses.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonProgressCountArgs} args - Arguments to filter LessonProgresses to count.
|
|
* @example
|
|
* // Count the number of LessonProgresses
|
|
* const count = await prisma.lessonProgress.count({
|
|
* where: {
|
|
* // ... the filter for the LessonProgresses we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends LessonProgressCountArgs>(
|
|
args?: Subset<T, LessonProgressCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], LessonProgressCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a LessonProgress.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonProgressAggregateArgs} 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 LessonProgressAggregateArgs>(args: Subset<T, LessonProgressAggregateArgs>): Prisma.PrismaPromise<GetLessonProgressAggregateType<T>>
|
|
|
|
/**
|
|
* Group by LessonProgress.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {LessonProgressGroupByArgs} 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 LessonProgressGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: LessonProgressGroupByArgs['orderBy'] }
|
|
: { orderBy?: LessonProgressGroupByArgs['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, LessonProgressGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLessonProgressGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the LessonProgress model
|
|
*/
|
|
readonly fields: LessonProgressFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for LessonProgress.
|
|
* 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__LessonProgressClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
lesson<T extends LessonDefaultArgs<ExtArgs> = {}>(args?: Subset<T, LessonDefaultArgs<ExtArgs>>): Prisma__LessonClient<$Result.GetResult<Prisma.$LessonPayload<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 LessonProgress model
|
|
*/
|
|
interface LessonProgressFieldRefs {
|
|
readonly id: FieldRef<"LessonProgress", 'String'>
|
|
readonly userId: FieldRef<"LessonProgress", 'String'>
|
|
readonly lessonId: FieldRef<"LessonProgress", 'String'>
|
|
readonly completedAt: FieldRef<"LessonProgress", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* LessonProgress findUnique
|
|
*/
|
|
export type LessonProgressFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which LessonProgress to fetch.
|
|
*/
|
|
where: LessonProgressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LessonProgress findUniqueOrThrow
|
|
*/
|
|
export type LessonProgressFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which LessonProgress to fetch.
|
|
*/
|
|
where: LessonProgressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LessonProgress findFirst
|
|
*/
|
|
export type LessonProgressFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which LessonProgress to fetch.
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LessonProgresses to fetch.
|
|
*/
|
|
orderBy?: LessonProgressOrderByWithRelationInput | LessonProgressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for LessonProgresses.
|
|
*/
|
|
cursor?: LessonProgressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LessonProgresses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LessonProgresses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of LessonProgresses.
|
|
*/
|
|
distinct?: LessonProgressScalarFieldEnum | LessonProgressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* LessonProgress findFirstOrThrow
|
|
*/
|
|
export type LessonProgressFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which LessonProgress to fetch.
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LessonProgresses to fetch.
|
|
*/
|
|
orderBy?: LessonProgressOrderByWithRelationInput | LessonProgressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for LessonProgresses.
|
|
*/
|
|
cursor?: LessonProgressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LessonProgresses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LessonProgresses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of LessonProgresses.
|
|
*/
|
|
distinct?: LessonProgressScalarFieldEnum | LessonProgressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* LessonProgress findMany
|
|
*/
|
|
export type LessonProgressFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which LessonProgresses to fetch.
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of LessonProgresses to fetch.
|
|
*/
|
|
orderBy?: LessonProgressOrderByWithRelationInput | LessonProgressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing LessonProgresses.
|
|
*/
|
|
cursor?: LessonProgressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` LessonProgresses from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` LessonProgresses.
|
|
*/
|
|
skip?: number
|
|
distinct?: LessonProgressScalarFieldEnum | LessonProgressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* LessonProgress create
|
|
*/
|
|
export type LessonProgressCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a LessonProgress.
|
|
*/
|
|
data: XOR<LessonProgressCreateInput, LessonProgressUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* LessonProgress createMany
|
|
*/
|
|
export type LessonProgressCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many LessonProgresses.
|
|
*/
|
|
data: LessonProgressCreateManyInput | LessonProgressCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* LessonProgress createManyAndReturn
|
|
*/
|
|
export type LessonProgressCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many LessonProgresses.
|
|
*/
|
|
data: LessonProgressCreateManyInput | LessonProgressCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* LessonProgress update
|
|
*/
|
|
export type LessonProgressUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a LessonProgress.
|
|
*/
|
|
data: XOR<LessonProgressUpdateInput, LessonProgressUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which LessonProgress to update.
|
|
*/
|
|
where: LessonProgressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LessonProgress updateMany
|
|
*/
|
|
export type LessonProgressUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update LessonProgresses.
|
|
*/
|
|
data: XOR<LessonProgressUpdateManyMutationInput, LessonProgressUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which LessonProgresses to update
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* Limit how many LessonProgresses to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* LessonProgress updateManyAndReturn
|
|
*/
|
|
export type LessonProgressUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update LessonProgresses.
|
|
*/
|
|
data: XOR<LessonProgressUpdateManyMutationInput, LessonProgressUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which LessonProgresses to update
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* Limit how many LessonProgresses to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* LessonProgress upsert
|
|
*/
|
|
export type LessonProgressUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the LessonProgress to update in case it exists.
|
|
*/
|
|
where: LessonProgressWhereUniqueInput
|
|
/**
|
|
* In case the LessonProgress found by the `where` argument doesn't exist, create a new LessonProgress with this data.
|
|
*/
|
|
create: XOR<LessonProgressCreateInput, LessonProgressUncheckedCreateInput>
|
|
/**
|
|
* In case the LessonProgress was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<LessonProgressUpdateInput, LessonProgressUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* LessonProgress delete
|
|
*/
|
|
export type LessonProgressDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which LessonProgress to delete.
|
|
*/
|
|
where: LessonProgressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* LessonProgress deleteMany
|
|
*/
|
|
export type LessonProgressDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which LessonProgresses to delete
|
|
*/
|
|
where?: LessonProgressWhereInput
|
|
/**
|
|
* Limit how many LessonProgresses to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* LessonProgress without action
|
|
*/
|
|
export type LessonProgressDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the LessonProgress
|
|
*/
|
|
select?: LessonProgressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the LessonProgress
|
|
*/
|
|
omit?: LessonProgressOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: LessonProgressInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model QuizAttempt
|
|
*/
|
|
|
|
export type AggregateQuizAttempt = {
|
|
_count: QuizAttemptCountAggregateOutputType | null
|
|
_avg: QuizAttemptAvgAggregateOutputType | null
|
|
_sum: QuizAttemptSumAggregateOutputType | null
|
|
_min: QuizAttemptMinAggregateOutputType | null
|
|
_max: QuizAttemptMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type QuizAttemptAvgAggregateOutputType = {
|
|
score: number | null
|
|
answers: number | null
|
|
}
|
|
|
|
export type QuizAttemptSumAggregateOutputType = {
|
|
score: number | null
|
|
answers: number[]
|
|
}
|
|
|
|
export type QuizAttemptMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
quizId: string | null
|
|
score: number | null
|
|
passed: boolean | null
|
|
completedAt: Date | null
|
|
}
|
|
|
|
export type QuizAttemptMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
quizId: string | null
|
|
score: number | null
|
|
passed: boolean | null
|
|
completedAt: Date | null
|
|
}
|
|
|
|
export type QuizAttemptCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
quizId: number
|
|
score: number
|
|
passed: number
|
|
answers: number
|
|
completedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type QuizAttemptAvgAggregateInputType = {
|
|
score?: true
|
|
answers?: true
|
|
}
|
|
|
|
export type QuizAttemptSumAggregateInputType = {
|
|
score?: true
|
|
answers?: true
|
|
}
|
|
|
|
export type QuizAttemptMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
quizId?: true
|
|
score?: true
|
|
passed?: true
|
|
completedAt?: true
|
|
}
|
|
|
|
export type QuizAttemptMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
quizId?: true
|
|
score?: true
|
|
passed?: true
|
|
completedAt?: true
|
|
}
|
|
|
|
export type QuizAttemptCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
quizId?: true
|
|
score?: true
|
|
passed?: true
|
|
answers?: true
|
|
completedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type QuizAttemptAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which QuizAttempt to aggregate.
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of QuizAttempts to fetch.
|
|
*/
|
|
orderBy?: QuizAttemptOrderByWithRelationInput | QuizAttemptOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: QuizAttemptWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` QuizAttempts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` QuizAttempts.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned QuizAttempts
|
|
**/
|
|
_count?: true | QuizAttemptCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: QuizAttemptAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: QuizAttemptSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: QuizAttemptMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: QuizAttemptMaxAggregateInputType
|
|
}
|
|
|
|
export type GetQuizAttemptAggregateType<T extends QuizAttemptAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateQuizAttempt]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateQuizAttempt[P]>
|
|
: GetScalarType<T[P], AggregateQuizAttempt[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type QuizAttemptGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: QuizAttemptWhereInput
|
|
orderBy?: QuizAttemptOrderByWithAggregationInput | QuizAttemptOrderByWithAggregationInput[]
|
|
by: QuizAttemptScalarFieldEnum[] | QuizAttemptScalarFieldEnum
|
|
having?: QuizAttemptScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: QuizAttemptCountAggregateInputType | true
|
|
_avg?: QuizAttemptAvgAggregateInputType
|
|
_sum?: QuizAttemptSumAggregateInputType
|
|
_min?: QuizAttemptMinAggregateInputType
|
|
_max?: QuizAttemptMaxAggregateInputType
|
|
}
|
|
|
|
export type QuizAttemptGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
quizId: string
|
|
score: number
|
|
passed: boolean
|
|
answers: number[]
|
|
completedAt: Date
|
|
_count: QuizAttemptCountAggregateOutputType | null
|
|
_avg: QuizAttemptAvgAggregateOutputType | null
|
|
_sum: QuizAttemptSumAggregateOutputType | null
|
|
_min: QuizAttemptMinAggregateOutputType | null
|
|
_max: QuizAttemptMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetQuizAttemptGroupByPayload<T extends QuizAttemptGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<QuizAttemptGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof QuizAttemptGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], QuizAttemptGroupByOutputType[P]>
|
|
: GetScalarType<T[P], QuizAttemptGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type QuizAttemptSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
quizId?: boolean
|
|
score?: boolean
|
|
passed?: boolean
|
|
answers?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["quizAttempt"]>
|
|
|
|
export type QuizAttemptSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
quizId?: boolean
|
|
score?: boolean
|
|
passed?: boolean
|
|
answers?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["quizAttempt"]>
|
|
|
|
export type QuizAttemptSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
quizId?: boolean
|
|
score?: boolean
|
|
passed?: boolean
|
|
answers?: boolean
|
|
completedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["quizAttempt"]>
|
|
|
|
export type QuizAttemptSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
quizId?: boolean
|
|
score?: boolean
|
|
passed?: boolean
|
|
answers?: boolean
|
|
completedAt?: boolean
|
|
}
|
|
|
|
export type QuizAttemptOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "quizId" | "score" | "passed" | "answers" | "completedAt", ExtArgs["result"]["quizAttempt"]>
|
|
export type QuizAttemptInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}
|
|
export type QuizAttemptIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}
|
|
export type QuizAttemptIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
quiz?: boolean | QuizDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $QuizAttemptPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "QuizAttempt"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
quiz: Prisma.$QuizPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
quizId: string
|
|
score: number
|
|
passed: boolean
|
|
answers: number[]
|
|
completedAt: Date
|
|
}, ExtArgs["result"]["quizAttempt"]>
|
|
composites: {}
|
|
}
|
|
|
|
type QuizAttemptGetPayload<S extends boolean | null | undefined | QuizAttemptDefaultArgs> = $Result.GetResult<Prisma.$QuizAttemptPayload, S>
|
|
|
|
type QuizAttemptCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<QuizAttemptFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: QuizAttemptCountAggregateInputType | true
|
|
}
|
|
|
|
export interface QuizAttemptDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['QuizAttempt'], meta: { name: 'QuizAttempt' } }
|
|
/**
|
|
* Find zero or one QuizAttempt that matches the filter.
|
|
* @param {QuizAttemptFindUniqueArgs} args - Arguments to find a QuizAttempt
|
|
* @example
|
|
* // Get one QuizAttempt
|
|
* const quizAttempt = await prisma.quizAttempt.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends QuizAttemptFindUniqueArgs>(args: SelectSubset<T, QuizAttemptFindUniqueArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one QuizAttempt that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {QuizAttemptFindUniqueOrThrowArgs} args - Arguments to find a QuizAttempt
|
|
* @example
|
|
* // Get one QuizAttempt
|
|
* const quizAttempt = await prisma.quizAttempt.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends QuizAttemptFindUniqueOrThrowArgs>(args: SelectSubset<T, QuizAttemptFindUniqueOrThrowArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first QuizAttempt 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 {QuizAttemptFindFirstArgs} args - Arguments to find a QuizAttempt
|
|
* @example
|
|
* // Get one QuizAttempt
|
|
* const quizAttempt = await prisma.quizAttempt.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends QuizAttemptFindFirstArgs>(args?: SelectSubset<T, QuizAttemptFindFirstArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first QuizAttempt 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 {QuizAttemptFindFirstOrThrowArgs} args - Arguments to find a QuizAttempt
|
|
* @example
|
|
* // Get one QuizAttempt
|
|
* const quizAttempt = await prisma.quizAttempt.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends QuizAttemptFindFirstOrThrowArgs>(args?: SelectSubset<T, QuizAttemptFindFirstOrThrowArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more QuizAttempts 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 {QuizAttemptFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all QuizAttempts
|
|
* const quizAttempts = await prisma.quizAttempt.findMany()
|
|
*
|
|
* // Get first 10 QuizAttempts
|
|
* const quizAttempts = await prisma.quizAttempt.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const quizAttemptWithIdOnly = await prisma.quizAttempt.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends QuizAttemptFindManyArgs>(args?: SelectSubset<T, QuizAttemptFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a QuizAttempt.
|
|
* @param {QuizAttemptCreateArgs} args - Arguments to create a QuizAttempt.
|
|
* @example
|
|
* // Create one QuizAttempt
|
|
* const QuizAttempt = await prisma.quizAttempt.create({
|
|
* data: {
|
|
* // ... data to create a QuizAttempt
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends QuizAttemptCreateArgs>(args: SelectSubset<T, QuizAttemptCreateArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many QuizAttempts.
|
|
* @param {QuizAttemptCreateManyArgs} args - Arguments to create many QuizAttempts.
|
|
* @example
|
|
* // Create many QuizAttempts
|
|
* const quizAttempt = await prisma.quizAttempt.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends QuizAttemptCreateManyArgs>(args?: SelectSubset<T, QuizAttemptCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many QuizAttempts and returns the data saved in the database.
|
|
* @param {QuizAttemptCreateManyAndReturnArgs} args - Arguments to create many QuizAttempts.
|
|
* @example
|
|
* // Create many QuizAttempts
|
|
* const quizAttempt = await prisma.quizAttempt.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many QuizAttempts and only return the `id`
|
|
* const quizAttemptWithIdOnly = await prisma.quizAttempt.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 QuizAttemptCreateManyAndReturnArgs>(args?: SelectSubset<T, QuizAttemptCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a QuizAttempt.
|
|
* @param {QuizAttemptDeleteArgs} args - Arguments to delete one QuizAttempt.
|
|
* @example
|
|
* // Delete one QuizAttempt
|
|
* const QuizAttempt = await prisma.quizAttempt.delete({
|
|
* where: {
|
|
* // ... filter to delete one QuizAttempt
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends QuizAttemptDeleteArgs>(args: SelectSubset<T, QuizAttemptDeleteArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one QuizAttempt.
|
|
* @param {QuizAttemptUpdateArgs} args - Arguments to update one QuizAttempt.
|
|
* @example
|
|
* // Update one QuizAttempt
|
|
* const quizAttempt = await prisma.quizAttempt.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends QuizAttemptUpdateArgs>(args: SelectSubset<T, QuizAttemptUpdateArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more QuizAttempts.
|
|
* @param {QuizAttemptDeleteManyArgs} args - Arguments to filter QuizAttempts to delete.
|
|
* @example
|
|
* // Delete a few QuizAttempts
|
|
* const { count } = await prisma.quizAttempt.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends QuizAttemptDeleteManyArgs>(args?: SelectSubset<T, QuizAttemptDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more QuizAttempts.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizAttemptUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many QuizAttempts
|
|
* const quizAttempt = await prisma.quizAttempt.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends QuizAttemptUpdateManyArgs>(args: SelectSubset<T, QuizAttemptUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more QuizAttempts and returns the data updated in the database.
|
|
* @param {QuizAttemptUpdateManyAndReturnArgs} args - Arguments to update many QuizAttempts.
|
|
* @example
|
|
* // Update many QuizAttempts
|
|
* const quizAttempt = await prisma.quizAttempt.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more QuizAttempts and only return the `id`
|
|
* const quizAttemptWithIdOnly = await prisma.quizAttempt.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 QuizAttemptUpdateManyAndReturnArgs>(args: SelectSubset<T, QuizAttemptUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one QuizAttempt.
|
|
* @param {QuizAttemptUpsertArgs} args - Arguments to update or create a QuizAttempt.
|
|
* @example
|
|
* // Update or create a QuizAttempt
|
|
* const quizAttempt = await prisma.quizAttempt.upsert({
|
|
* create: {
|
|
* // ... data to create a QuizAttempt
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the QuizAttempt we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends QuizAttemptUpsertArgs>(args: SelectSubset<T, QuizAttemptUpsertArgs<ExtArgs>>): Prisma__QuizAttemptClient<$Result.GetResult<Prisma.$QuizAttemptPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of QuizAttempts.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizAttemptCountArgs} args - Arguments to filter QuizAttempts to count.
|
|
* @example
|
|
* // Count the number of QuizAttempts
|
|
* const count = await prisma.quizAttempt.count({
|
|
* where: {
|
|
* // ... the filter for the QuizAttempts we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends QuizAttemptCountArgs>(
|
|
args?: Subset<T, QuizAttemptCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], QuizAttemptCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a QuizAttempt.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizAttemptAggregateArgs} 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 QuizAttemptAggregateArgs>(args: Subset<T, QuizAttemptAggregateArgs>): Prisma.PrismaPromise<GetQuizAttemptAggregateType<T>>
|
|
|
|
/**
|
|
* Group by QuizAttempt.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {QuizAttemptGroupByArgs} 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 QuizAttemptGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: QuizAttemptGroupByArgs['orderBy'] }
|
|
: { orderBy?: QuizAttemptGroupByArgs['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, QuizAttemptGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuizAttemptGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the QuizAttempt model
|
|
*/
|
|
readonly fields: QuizAttemptFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for QuizAttempt.
|
|
* 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__QuizAttemptClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
quiz<T extends QuizDefaultArgs<ExtArgs> = {}>(args?: Subset<T, QuizDefaultArgs<ExtArgs>>): Prisma__QuizClient<$Result.GetResult<Prisma.$QuizPayload<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 QuizAttempt model
|
|
*/
|
|
interface QuizAttemptFieldRefs {
|
|
readonly id: FieldRef<"QuizAttempt", 'String'>
|
|
readonly userId: FieldRef<"QuizAttempt", 'String'>
|
|
readonly quizId: FieldRef<"QuizAttempt", 'String'>
|
|
readonly score: FieldRef<"QuizAttempt", 'Int'>
|
|
readonly passed: FieldRef<"QuizAttempt", 'Boolean'>
|
|
readonly answers: FieldRef<"QuizAttempt", 'Int[]'>
|
|
readonly completedAt: FieldRef<"QuizAttempt", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* QuizAttempt findUnique
|
|
*/
|
|
export type QuizAttemptFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which QuizAttempt to fetch.
|
|
*/
|
|
where: QuizAttemptWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt findUniqueOrThrow
|
|
*/
|
|
export type QuizAttemptFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which QuizAttempt to fetch.
|
|
*/
|
|
where: QuizAttemptWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt findFirst
|
|
*/
|
|
export type QuizAttemptFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which QuizAttempt to fetch.
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of QuizAttempts to fetch.
|
|
*/
|
|
orderBy?: QuizAttemptOrderByWithRelationInput | QuizAttemptOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for QuizAttempts.
|
|
*/
|
|
cursor?: QuizAttemptWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` QuizAttempts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` QuizAttempts.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of QuizAttempts.
|
|
*/
|
|
distinct?: QuizAttemptScalarFieldEnum | QuizAttemptScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt findFirstOrThrow
|
|
*/
|
|
export type QuizAttemptFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which QuizAttempt to fetch.
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of QuizAttempts to fetch.
|
|
*/
|
|
orderBy?: QuizAttemptOrderByWithRelationInput | QuizAttemptOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for QuizAttempts.
|
|
*/
|
|
cursor?: QuizAttemptWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` QuizAttempts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` QuizAttempts.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of QuizAttempts.
|
|
*/
|
|
distinct?: QuizAttemptScalarFieldEnum | QuizAttemptScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt findMany
|
|
*/
|
|
export type QuizAttemptFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which QuizAttempts to fetch.
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of QuizAttempts to fetch.
|
|
*/
|
|
orderBy?: QuizAttemptOrderByWithRelationInput | QuizAttemptOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing QuizAttempts.
|
|
*/
|
|
cursor?: QuizAttemptWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` QuizAttempts from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` QuizAttempts.
|
|
*/
|
|
skip?: number
|
|
distinct?: QuizAttemptScalarFieldEnum | QuizAttemptScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt create
|
|
*/
|
|
export type QuizAttemptCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a QuizAttempt.
|
|
*/
|
|
data: XOR<QuizAttemptCreateInput, QuizAttemptUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt createMany
|
|
*/
|
|
export type QuizAttemptCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many QuizAttempts.
|
|
*/
|
|
data: QuizAttemptCreateManyInput | QuizAttemptCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt createManyAndReturn
|
|
*/
|
|
export type QuizAttemptCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many QuizAttempts.
|
|
*/
|
|
data: QuizAttemptCreateManyInput | QuizAttemptCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt update
|
|
*/
|
|
export type QuizAttemptUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a QuizAttempt.
|
|
*/
|
|
data: XOR<QuizAttemptUpdateInput, QuizAttemptUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which QuizAttempt to update.
|
|
*/
|
|
where: QuizAttemptWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt updateMany
|
|
*/
|
|
export type QuizAttemptUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update QuizAttempts.
|
|
*/
|
|
data: XOR<QuizAttemptUpdateManyMutationInput, QuizAttemptUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which QuizAttempts to update
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* Limit how many QuizAttempts to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt updateManyAndReturn
|
|
*/
|
|
export type QuizAttemptUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update QuizAttempts.
|
|
*/
|
|
data: XOR<QuizAttemptUpdateManyMutationInput, QuizAttemptUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which QuizAttempts to update
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* Limit how many QuizAttempts to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt upsert
|
|
*/
|
|
export type QuizAttemptUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the QuizAttempt to update in case it exists.
|
|
*/
|
|
where: QuizAttemptWhereUniqueInput
|
|
/**
|
|
* In case the QuizAttempt found by the `where` argument doesn't exist, create a new QuizAttempt with this data.
|
|
*/
|
|
create: XOR<QuizAttemptCreateInput, QuizAttemptUncheckedCreateInput>
|
|
/**
|
|
* In case the QuizAttempt was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<QuizAttemptUpdateInput, QuizAttemptUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt delete
|
|
*/
|
|
export type QuizAttemptDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which QuizAttempt to delete.
|
|
*/
|
|
where: QuizAttemptWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt deleteMany
|
|
*/
|
|
export type QuizAttemptDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which QuizAttempts to delete
|
|
*/
|
|
where?: QuizAttemptWhereInput
|
|
/**
|
|
* Limit how many QuizAttempts to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* QuizAttempt without action
|
|
*/
|
|
export type QuizAttemptDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the QuizAttempt
|
|
*/
|
|
select?: QuizAttemptSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the QuizAttempt
|
|
*/
|
|
omit?: QuizAttemptOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: QuizAttemptInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Certificate
|
|
*/
|
|
|
|
export type AggregateCertificate = {
|
|
_count: CertificateCountAggregateOutputType | null
|
|
_min: CertificateMinAggregateOutputType | null
|
|
_max: CertificateMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type CertificateMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
courseId: string | null
|
|
issuedAt: Date | null
|
|
pdfUrl: string | null
|
|
isPaid: boolean | null
|
|
}
|
|
|
|
export type CertificateMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
courseId: string | null
|
|
issuedAt: Date | null
|
|
pdfUrl: string | null
|
|
isPaid: boolean | null
|
|
}
|
|
|
|
export type CertificateCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
courseId: number
|
|
issuedAt: number
|
|
pdfUrl: number
|
|
isPaid: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type CertificateMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
courseId?: true
|
|
issuedAt?: true
|
|
pdfUrl?: true
|
|
isPaid?: true
|
|
}
|
|
|
|
export type CertificateMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
courseId?: true
|
|
issuedAt?: true
|
|
pdfUrl?: true
|
|
isPaid?: true
|
|
}
|
|
|
|
export type CertificateCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
courseId?: true
|
|
issuedAt?: true
|
|
pdfUrl?: true
|
|
isPaid?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type CertificateAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Certificate to aggregate.
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Certificates to fetch.
|
|
*/
|
|
orderBy?: CertificateOrderByWithRelationInput | CertificateOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: CertificateWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Certificates from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Certificates.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Certificates
|
|
**/
|
|
_count?: true | CertificateCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: CertificateMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: CertificateMaxAggregateInputType
|
|
}
|
|
|
|
export type GetCertificateAggregateType<T extends CertificateAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateCertificate]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateCertificate[P]>
|
|
: GetScalarType<T[P], AggregateCertificate[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type CertificateGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: CertificateWhereInput
|
|
orderBy?: CertificateOrderByWithAggregationInput | CertificateOrderByWithAggregationInput[]
|
|
by: CertificateScalarFieldEnum[] | CertificateScalarFieldEnum
|
|
having?: CertificateScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: CertificateCountAggregateInputType | true
|
|
_min?: CertificateMinAggregateInputType
|
|
_max?: CertificateMaxAggregateInputType
|
|
}
|
|
|
|
export type CertificateGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
courseId: string
|
|
issuedAt: Date
|
|
pdfUrl: string | null
|
|
isPaid: boolean
|
|
_count: CertificateCountAggregateOutputType | null
|
|
_min: CertificateMinAggregateOutputType | null
|
|
_max: CertificateMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetCertificateGroupByPayload<T extends CertificateGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<CertificateGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof CertificateGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], CertificateGroupByOutputType[P]>
|
|
: GetScalarType<T[P], CertificateGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type CertificateSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
issuedAt?: boolean
|
|
pdfUrl?: boolean
|
|
isPaid?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["certificate"]>
|
|
|
|
export type CertificateSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
issuedAt?: boolean
|
|
pdfUrl?: boolean
|
|
isPaid?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["certificate"]>
|
|
|
|
export type CertificateSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
issuedAt?: boolean
|
|
pdfUrl?: boolean
|
|
isPaid?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["certificate"]>
|
|
|
|
export type CertificateSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
courseId?: boolean
|
|
issuedAt?: boolean
|
|
pdfUrl?: boolean
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type CertificateOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "courseId" | "issuedAt" | "pdfUrl" | "isPaid", ExtArgs["result"]["certificate"]>
|
|
export type CertificateInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
export type CertificateIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
export type CertificateIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
course?: boolean | CourseDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $CertificatePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Certificate"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
course: Prisma.$CoursePayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
courseId: string
|
|
issuedAt: Date
|
|
pdfUrl: string | null
|
|
isPaid: boolean
|
|
}, ExtArgs["result"]["certificate"]>
|
|
composites: {}
|
|
}
|
|
|
|
type CertificateGetPayload<S extends boolean | null | undefined | CertificateDefaultArgs> = $Result.GetResult<Prisma.$CertificatePayload, S>
|
|
|
|
type CertificateCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<CertificateFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: CertificateCountAggregateInputType | true
|
|
}
|
|
|
|
export interface CertificateDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Certificate'], meta: { name: 'Certificate' } }
|
|
/**
|
|
* Find zero or one Certificate that matches the filter.
|
|
* @param {CertificateFindUniqueArgs} args - Arguments to find a Certificate
|
|
* @example
|
|
* // Get one Certificate
|
|
* const certificate = await prisma.certificate.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends CertificateFindUniqueArgs>(args: SelectSubset<T, CertificateFindUniqueArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Certificate that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {CertificateFindUniqueOrThrowArgs} args - Arguments to find a Certificate
|
|
* @example
|
|
* // Get one Certificate
|
|
* const certificate = await prisma.certificate.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends CertificateFindUniqueOrThrowArgs>(args: SelectSubset<T, CertificateFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Certificate 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 {CertificateFindFirstArgs} args - Arguments to find a Certificate
|
|
* @example
|
|
* // Get one Certificate
|
|
* const certificate = await prisma.certificate.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends CertificateFindFirstArgs>(args?: SelectSubset<T, CertificateFindFirstArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Certificate 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 {CertificateFindFirstOrThrowArgs} args - Arguments to find a Certificate
|
|
* @example
|
|
* // Get one Certificate
|
|
* const certificate = await prisma.certificate.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends CertificateFindFirstOrThrowArgs>(args?: SelectSubset<T, CertificateFindFirstOrThrowArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Certificates 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 {CertificateFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Certificates
|
|
* const certificates = await prisma.certificate.findMany()
|
|
*
|
|
* // Get first 10 Certificates
|
|
* const certificates = await prisma.certificate.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const certificateWithIdOnly = await prisma.certificate.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends CertificateFindManyArgs>(args?: SelectSubset<T, CertificateFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Certificate.
|
|
* @param {CertificateCreateArgs} args - Arguments to create a Certificate.
|
|
* @example
|
|
* // Create one Certificate
|
|
* const Certificate = await prisma.certificate.create({
|
|
* data: {
|
|
* // ... data to create a Certificate
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends CertificateCreateArgs>(args: SelectSubset<T, CertificateCreateArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Certificates.
|
|
* @param {CertificateCreateManyArgs} args - Arguments to create many Certificates.
|
|
* @example
|
|
* // Create many Certificates
|
|
* const certificate = await prisma.certificate.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends CertificateCreateManyArgs>(args?: SelectSubset<T, CertificateCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Certificates and returns the data saved in the database.
|
|
* @param {CertificateCreateManyAndReturnArgs} args - Arguments to create many Certificates.
|
|
* @example
|
|
* // Create many Certificates
|
|
* const certificate = await prisma.certificate.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Certificates and only return the `id`
|
|
* const certificateWithIdOnly = await prisma.certificate.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 CertificateCreateManyAndReturnArgs>(args?: SelectSubset<T, CertificateCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Certificate.
|
|
* @param {CertificateDeleteArgs} args - Arguments to delete one Certificate.
|
|
* @example
|
|
* // Delete one Certificate
|
|
* const Certificate = await prisma.certificate.delete({
|
|
* where: {
|
|
* // ... filter to delete one Certificate
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends CertificateDeleteArgs>(args: SelectSubset<T, CertificateDeleteArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Certificate.
|
|
* @param {CertificateUpdateArgs} args - Arguments to update one Certificate.
|
|
* @example
|
|
* // Update one Certificate
|
|
* const certificate = await prisma.certificate.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends CertificateUpdateArgs>(args: SelectSubset<T, CertificateUpdateArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Certificates.
|
|
* @param {CertificateDeleteManyArgs} args - Arguments to filter Certificates to delete.
|
|
* @example
|
|
* // Delete a few Certificates
|
|
* const { count } = await prisma.certificate.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends CertificateDeleteManyArgs>(args?: SelectSubset<T, CertificateDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Certificates.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CertificateUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Certificates
|
|
* const certificate = await prisma.certificate.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends CertificateUpdateManyArgs>(args: SelectSubset<T, CertificateUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Certificates and returns the data updated in the database.
|
|
* @param {CertificateUpdateManyAndReturnArgs} args - Arguments to update many Certificates.
|
|
* @example
|
|
* // Update many Certificates
|
|
* const certificate = await prisma.certificate.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Certificates and only return the `id`
|
|
* const certificateWithIdOnly = await prisma.certificate.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 CertificateUpdateManyAndReturnArgs>(args: SelectSubset<T, CertificateUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Certificate.
|
|
* @param {CertificateUpsertArgs} args - Arguments to update or create a Certificate.
|
|
* @example
|
|
* // Update or create a Certificate
|
|
* const certificate = await prisma.certificate.upsert({
|
|
* create: {
|
|
* // ... data to create a Certificate
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Certificate we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends CertificateUpsertArgs>(args: SelectSubset<T, CertificateUpsertArgs<ExtArgs>>): Prisma__CertificateClient<$Result.GetResult<Prisma.$CertificatePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Certificates.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CertificateCountArgs} args - Arguments to filter Certificates to count.
|
|
* @example
|
|
* // Count the number of Certificates
|
|
* const count = await prisma.certificate.count({
|
|
* where: {
|
|
* // ... the filter for the Certificates we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends CertificateCountArgs>(
|
|
args?: Subset<T, CertificateCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], CertificateCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Certificate.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CertificateAggregateArgs} 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 CertificateAggregateArgs>(args: Subset<T, CertificateAggregateArgs>): Prisma.PrismaPromise<GetCertificateAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Certificate.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CertificateGroupByArgs} 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 CertificateGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: CertificateGroupByArgs['orderBy'] }
|
|
: { orderBy?: CertificateGroupByArgs['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, CertificateGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCertificateGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Certificate model
|
|
*/
|
|
readonly fields: CertificateFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Certificate.
|
|
* 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__CertificateClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
course<T extends CourseDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CourseDefaultArgs<ExtArgs>>): Prisma__CourseClient<$Result.GetResult<Prisma.$CoursePayload<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 Certificate model
|
|
*/
|
|
interface CertificateFieldRefs {
|
|
readonly id: FieldRef<"Certificate", 'String'>
|
|
readonly userId: FieldRef<"Certificate", 'String'>
|
|
readonly courseId: FieldRef<"Certificate", 'String'>
|
|
readonly issuedAt: FieldRef<"Certificate", 'DateTime'>
|
|
readonly pdfUrl: FieldRef<"Certificate", 'String'>
|
|
readonly isPaid: FieldRef<"Certificate", 'Boolean'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Certificate findUnique
|
|
*/
|
|
export type CertificateFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Certificate to fetch.
|
|
*/
|
|
where: CertificateWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Certificate findUniqueOrThrow
|
|
*/
|
|
export type CertificateFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Certificate to fetch.
|
|
*/
|
|
where: CertificateWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Certificate findFirst
|
|
*/
|
|
export type CertificateFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Certificate to fetch.
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Certificates to fetch.
|
|
*/
|
|
orderBy?: CertificateOrderByWithRelationInput | CertificateOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Certificates.
|
|
*/
|
|
cursor?: CertificateWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Certificates from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Certificates.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Certificates.
|
|
*/
|
|
distinct?: CertificateScalarFieldEnum | CertificateScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Certificate findFirstOrThrow
|
|
*/
|
|
export type CertificateFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Certificate to fetch.
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Certificates to fetch.
|
|
*/
|
|
orderBy?: CertificateOrderByWithRelationInput | CertificateOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Certificates.
|
|
*/
|
|
cursor?: CertificateWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Certificates from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Certificates.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Certificates.
|
|
*/
|
|
distinct?: CertificateScalarFieldEnum | CertificateScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Certificate findMany
|
|
*/
|
|
export type CertificateFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Certificates to fetch.
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Certificates to fetch.
|
|
*/
|
|
orderBy?: CertificateOrderByWithRelationInput | CertificateOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Certificates.
|
|
*/
|
|
cursor?: CertificateWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Certificates from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Certificates.
|
|
*/
|
|
skip?: number
|
|
distinct?: CertificateScalarFieldEnum | CertificateScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Certificate create
|
|
*/
|
|
export type CertificateCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Certificate.
|
|
*/
|
|
data: XOR<CertificateCreateInput, CertificateUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Certificate createMany
|
|
*/
|
|
export type CertificateCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Certificates.
|
|
*/
|
|
data: CertificateCreateManyInput | CertificateCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Certificate createManyAndReturn
|
|
*/
|
|
export type CertificateCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Certificates.
|
|
*/
|
|
data: CertificateCreateManyInput | CertificateCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Certificate update
|
|
*/
|
|
export type CertificateUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Certificate.
|
|
*/
|
|
data: XOR<CertificateUpdateInput, CertificateUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Certificate to update.
|
|
*/
|
|
where: CertificateWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Certificate updateMany
|
|
*/
|
|
export type CertificateUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Certificates.
|
|
*/
|
|
data: XOR<CertificateUpdateManyMutationInput, CertificateUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Certificates to update
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* Limit how many Certificates to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Certificate updateManyAndReturn
|
|
*/
|
|
export type CertificateUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Certificates.
|
|
*/
|
|
data: XOR<CertificateUpdateManyMutationInput, CertificateUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Certificates to update
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* Limit how many Certificates to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Certificate upsert
|
|
*/
|
|
export type CertificateUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Certificate to update in case it exists.
|
|
*/
|
|
where: CertificateWhereUniqueInput
|
|
/**
|
|
* In case the Certificate found by the `where` argument doesn't exist, create a new Certificate with this data.
|
|
*/
|
|
create: XOR<CertificateCreateInput, CertificateUncheckedCreateInput>
|
|
/**
|
|
* In case the Certificate was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<CertificateUpdateInput, CertificateUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Certificate delete
|
|
*/
|
|
export type CertificateDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Certificate to delete.
|
|
*/
|
|
where: CertificateWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Certificate deleteMany
|
|
*/
|
|
export type CertificateDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Certificates to delete
|
|
*/
|
|
where?: CertificateWhereInput
|
|
/**
|
|
* Limit how many Certificates to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Certificate without action
|
|
*/
|
|
export type CertificateDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Certificate
|
|
*/
|
|
select?: CertificateSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Certificate
|
|
*/
|
|
omit?: CertificateOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CertificateInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Enums
|
|
*/
|
|
|
|
export const TransactionIsolationLevel: {
|
|
ReadUncommitted: 'ReadUncommitted',
|
|
ReadCommitted: 'ReadCommitted',
|
|
RepeatableRead: 'RepeatableRead',
|
|
Serializable: 'Serializable'
|
|
};
|
|
|
|
export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
|
|
|
|
|
|
export const UserScalarFieldEnum: {
|
|
id: 'id',
|
|
email: 'email',
|
|
name: 'name',
|
|
image: 'image',
|
|
emailVerified: 'emailVerified',
|
|
locale: 'locale',
|
|
role: 'role',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
|
|
|
|
|
|
export const AccountScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
type: 'type',
|
|
provider: 'provider',
|
|
providerAccountId: 'providerAccountId',
|
|
refresh_token: 'refresh_token',
|
|
access_token: 'access_token',
|
|
expires_at: 'expires_at',
|
|
token_type: 'token_type',
|
|
scope: 'scope',
|
|
id_token: 'id_token',
|
|
session_state: 'session_state'
|
|
};
|
|
|
|
export type AccountScalarFieldEnum = (typeof AccountScalarFieldEnum)[keyof typeof AccountScalarFieldEnum]
|
|
|
|
|
|
export const SessionScalarFieldEnum: {
|
|
id: 'id',
|
|
sessionToken: 'sessionToken',
|
|
userId: 'userId',
|
|
expires: 'expires'
|
|
};
|
|
|
|
export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum]
|
|
|
|
|
|
export const VerificationTokenScalarFieldEnum: {
|
|
identifier: 'identifier',
|
|
token: 'token',
|
|
expires: 'expires'
|
|
};
|
|
|
|
export type VerificationTokenScalarFieldEnum = (typeof VerificationTokenScalarFieldEnum)[keyof typeof VerificationTokenScalarFieldEnum]
|
|
|
|
|
|
export const CourseScalarFieldEnum: {
|
|
id: 'id',
|
|
slug: 'slug',
|
|
category: 'category',
|
|
level: 'level',
|
|
thumbnailUrl: 'thumbnailUrl',
|
|
published: 'published',
|
|
order: 'order',
|
|
createdAt: 'createdAt',
|
|
titleFr: 'titleFr',
|
|
titleEn: 'titleEn',
|
|
titleEs: 'titleEs',
|
|
descFr: 'descFr',
|
|
descEn: 'descEn',
|
|
descEs: 'descEs'
|
|
};
|
|
|
|
export type CourseScalarFieldEnum = (typeof CourseScalarFieldEnum)[keyof typeof CourseScalarFieldEnum]
|
|
|
|
|
|
export const ModuleScalarFieldEnum: {
|
|
id: 'id',
|
|
courseId: 'courseId',
|
|
order: 'order',
|
|
titleFr: 'titleFr',
|
|
titleEn: 'titleEn',
|
|
titleEs: 'titleEs'
|
|
};
|
|
|
|
export type ModuleScalarFieldEnum = (typeof ModuleScalarFieldEnum)[keyof typeof ModuleScalarFieldEnum]
|
|
|
|
|
|
export const LessonScalarFieldEnum: {
|
|
id: 'id',
|
|
moduleId: 'moduleId',
|
|
order: 'order',
|
|
type: 'type',
|
|
videoUrl: 'videoUrl',
|
|
duration: 'duration',
|
|
titleFr: 'titleFr',
|
|
titleEn: 'titleEn',
|
|
titleEs: 'titleEs',
|
|
contentFr: 'contentFr',
|
|
contentEn: 'contentEn',
|
|
contentEs: 'contentEs'
|
|
};
|
|
|
|
export type LessonScalarFieldEnum = (typeof LessonScalarFieldEnum)[keyof typeof LessonScalarFieldEnum]
|
|
|
|
|
|
export const QuizScalarFieldEnum: {
|
|
id: 'id',
|
|
moduleId: 'moduleId',
|
|
passMark: 'passMark'
|
|
};
|
|
|
|
export type QuizScalarFieldEnum = (typeof QuizScalarFieldEnum)[keyof typeof QuizScalarFieldEnum]
|
|
|
|
|
|
export const QuestionScalarFieldEnum: {
|
|
id: 'id',
|
|
quizId: 'quizId',
|
|
order: 'order',
|
|
textFr: 'textFr',
|
|
textEn: 'textEn',
|
|
textEs: 'textEs',
|
|
optionsFr: 'optionsFr',
|
|
optionsEn: 'optionsEn',
|
|
optionsEs: 'optionsEs',
|
|
correctIndex: 'correctIndex'
|
|
};
|
|
|
|
export type QuestionScalarFieldEnum = (typeof QuestionScalarFieldEnum)[keyof typeof QuestionScalarFieldEnum]
|
|
|
|
|
|
export const EnrollmentScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
courseId: 'courseId',
|
|
enrolledAt: 'enrolledAt',
|
|
completedAt: 'completedAt'
|
|
};
|
|
|
|
export type EnrollmentScalarFieldEnum = (typeof EnrollmentScalarFieldEnum)[keyof typeof EnrollmentScalarFieldEnum]
|
|
|
|
|
|
export const LessonProgressScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
lessonId: 'lessonId',
|
|
completedAt: 'completedAt'
|
|
};
|
|
|
|
export type LessonProgressScalarFieldEnum = (typeof LessonProgressScalarFieldEnum)[keyof typeof LessonProgressScalarFieldEnum]
|
|
|
|
|
|
export const QuizAttemptScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
quizId: 'quizId',
|
|
score: 'score',
|
|
passed: 'passed',
|
|
answers: 'answers',
|
|
completedAt: 'completedAt'
|
|
};
|
|
|
|
export type QuizAttemptScalarFieldEnum = (typeof QuizAttemptScalarFieldEnum)[keyof typeof QuizAttemptScalarFieldEnum]
|
|
|
|
|
|
export const CertificateScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
courseId: 'courseId',
|
|
issuedAt: 'issuedAt',
|
|
pdfUrl: 'pdfUrl',
|
|
isPaid: 'isPaid'
|
|
};
|
|
|
|
export type CertificateScalarFieldEnum = (typeof CertificateScalarFieldEnum)[keyof typeof CertificateScalarFieldEnum]
|
|
|
|
|
|
export const SortOrder: {
|
|
asc: 'asc',
|
|
desc: 'desc'
|
|
};
|
|
|
|
export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
|
|
|
|
|
|
export const QueryMode: {
|
|
default: 'default',
|
|
insensitive: 'insensitive'
|
|
};
|
|
|
|
export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
|
|
|
|
|
|
export const NullsOrder: {
|
|
first: 'first',
|
|
last: 'last'
|
|
};
|
|
|
|
export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
|
|
|
|
|
|
/**
|
|
* Field references
|
|
*/
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'String'
|
|
*/
|
|
export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'String[]'
|
|
*/
|
|
export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type '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 'Role'
|
|
*/
|
|
export type EnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Role[]'
|
|
*/
|
|
export type ListEnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role[]'>
|
|
|
|
|
|
|
|
/**
|
|
* 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 'CourseCategory'
|
|
*/
|
|
export type EnumCourseCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CourseCategory'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'CourseCategory[]'
|
|
*/
|
|
export type ListEnumCourseCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CourseCategory[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'CourseLevel'
|
|
*/
|
|
export type EnumCourseLevelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CourseLevel'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'CourseLevel[]'
|
|
*/
|
|
export type ListEnumCourseLevelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CourseLevel[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Boolean'
|
|
*/
|
|
export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'LessonType'
|
|
*/
|
|
export type EnumLessonTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LessonType'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'LessonType[]'
|
|
*/
|
|
export type ListEnumLessonTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LessonType[]'>
|
|
|
|
|
|
|
|
/**
|
|
* 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[]'>
|
|
|
|
/**
|
|
* Deep Input Types
|
|
*/
|
|
|
|
|
|
export type UserWhereInput = {
|
|
AND?: UserWhereInput | UserWhereInput[]
|
|
OR?: UserWhereInput[]
|
|
NOT?: UserWhereInput | UserWhereInput[]
|
|
id?: StringFilter<"User"> | string
|
|
email?: StringFilter<"User"> | string
|
|
name?: StringNullableFilter<"User"> | string | null
|
|
image?: StringNullableFilter<"User"> | string | null
|
|
emailVerified?: DateTimeNullableFilter<"User"> | Date | string | null
|
|
locale?: StringFilter<"User"> | string
|
|
role?: EnumRoleFilter<"User"> | $Enums.Role
|
|
createdAt?: DateTimeFilter<"User"> | Date | string
|
|
accounts?: AccountListRelationFilter
|
|
sessions?: SessionListRelationFilter
|
|
enrollments?: EnrollmentListRelationFilter
|
|
lessonProgress?: LessonProgressListRelationFilter
|
|
quizAttempts?: QuizAttemptListRelationFilter
|
|
certificates?: CertificateListRelationFilter
|
|
}
|
|
|
|
export type UserOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
email?: SortOrder
|
|
name?: SortOrderInput | SortOrder
|
|
image?: SortOrderInput | SortOrder
|
|
emailVerified?: SortOrderInput | SortOrder
|
|
locale?: SortOrder
|
|
role?: SortOrder
|
|
createdAt?: SortOrder
|
|
accounts?: AccountOrderByRelationAggregateInput
|
|
sessions?: SessionOrderByRelationAggregateInput
|
|
enrollments?: EnrollmentOrderByRelationAggregateInput
|
|
lessonProgress?: LessonProgressOrderByRelationAggregateInput
|
|
quizAttempts?: QuizAttemptOrderByRelationAggregateInput
|
|
certificates?: CertificateOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type UserWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
email?: string
|
|
AND?: UserWhereInput | UserWhereInput[]
|
|
OR?: UserWhereInput[]
|
|
NOT?: UserWhereInput | UserWhereInput[]
|
|
name?: StringNullableFilter<"User"> | string | null
|
|
image?: StringNullableFilter<"User"> | string | null
|
|
emailVerified?: DateTimeNullableFilter<"User"> | Date | string | null
|
|
locale?: StringFilter<"User"> | string
|
|
role?: EnumRoleFilter<"User"> | $Enums.Role
|
|
createdAt?: DateTimeFilter<"User"> | Date | string
|
|
accounts?: AccountListRelationFilter
|
|
sessions?: SessionListRelationFilter
|
|
enrollments?: EnrollmentListRelationFilter
|
|
lessonProgress?: LessonProgressListRelationFilter
|
|
quizAttempts?: QuizAttemptListRelationFilter
|
|
certificates?: CertificateListRelationFilter
|
|
}, "id" | "email">
|
|
|
|
export type UserOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
email?: SortOrder
|
|
name?: SortOrderInput | SortOrder
|
|
image?: SortOrderInput | SortOrder
|
|
emailVerified?: SortOrderInput | SortOrder
|
|
locale?: SortOrder
|
|
role?: SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: UserCountOrderByAggregateInput
|
|
_max?: UserMaxOrderByAggregateInput
|
|
_min?: UserMinOrderByAggregateInput
|
|
}
|
|
|
|
export type UserScalarWhereWithAggregatesInput = {
|
|
AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
|
|
OR?: UserScalarWhereWithAggregatesInput[]
|
|
NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"User"> | string
|
|
email?: StringWithAggregatesFilter<"User"> | string
|
|
name?: StringNullableWithAggregatesFilter<"User"> | string | null
|
|
image?: StringNullableWithAggregatesFilter<"User"> | string | null
|
|
emailVerified?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
|
|
locale?: StringWithAggregatesFilter<"User"> | string
|
|
role?: EnumRoleWithAggregatesFilter<"User"> | $Enums.Role
|
|
createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
|
|
}
|
|
|
|
export type AccountWhereInput = {
|
|
AND?: AccountWhereInput | AccountWhereInput[]
|
|
OR?: AccountWhereInput[]
|
|
NOT?: AccountWhereInput | AccountWhereInput[]
|
|
id?: StringFilter<"Account"> | string
|
|
userId?: StringFilter<"Account"> | string
|
|
type?: StringFilter<"Account"> | string
|
|
provider?: StringFilter<"Account"> | string
|
|
providerAccountId?: StringFilter<"Account"> | string
|
|
refresh_token?: StringNullableFilter<"Account"> | string | null
|
|
access_token?: StringNullableFilter<"Account"> | string | null
|
|
expires_at?: IntNullableFilter<"Account"> | number | null
|
|
token_type?: StringNullableFilter<"Account"> | string | null
|
|
scope?: StringNullableFilter<"Account"> | string | null
|
|
id_token?: StringNullableFilter<"Account"> | string | null
|
|
session_state?: StringNullableFilter<"Account"> | string | null
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
}
|
|
|
|
export type AccountOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
type?: SortOrder
|
|
provider?: SortOrder
|
|
providerAccountId?: SortOrder
|
|
refresh_token?: SortOrderInput | SortOrder
|
|
access_token?: SortOrderInput | SortOrder
|
|
expires_at?: SortOrderInput | SortOrder
|
|
token_type?: SortOrderInput | SortOrder
|
|
scope?: SortOrderInput | SortOrder
|
|
id_token?: SortOrderInput | SortOrder
|
|
session_state?: SortOrderInput | SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
}
|
|
|
|
export type AccountWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
provider_providerAccountId?: AccountProviderProviderAccountIdCompoundUniqueInput
|
|
AND?: AccountWhereInput | AccountWhereInput[]
|
|
OR?: AccountWhereInput[]
|
|
NOT?: AccountWhereInput | AccountWhereInput[]
|
|
userId?: StringFilter<"Account"> | string
|
|
type?: StringFilter<"Account"> | string
|
|
provider?: StringFilter<"Account"> | string
|
|
providerAccountId?: StringFilter<"Account"> | string
|
|
refresh_token?: StringNullableFilter<"Account"> | string | null
|
|
access_token?: StringNullableFilter<"Account"> | string | null
|
|
expires_at?: IntNullableFilter<"Account"> | number | null
|
|
token_type?: StringNullableFilter<"Account"> | string | null
|
|
scope?: StringNullableFilter<"Account"> | string | null
|
|
id_token?: StringNullableFilter<"Account"> | string | null
|
|
session_state?: StringNullableFilter<"Account"> | string | null
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
}, "id" | "provider_providerAccountId">
|
|
|
|
export type AccountOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
type?: SortOrder
|
|
provider?: SortOrder
|
|
providerAccountId?: SortOrder
|
|
refresh_token?: SortOrderInput | SortOrder
|
|
access_token?: SortOrderInput | SortOrder
|
|
expires_at?: SortOrderInput | SortOrder
|
|
token_type?: SortOrderInput | SortOrder
|
|
scope?: SortOrderInput | SortOrder
|
|
id_token?: SortOrderInput | SortOrder
|
|
session_state?: SortOrderInput | SortOrder
|
|
_count?: AccountCountOrderByAggregateInput
|
|
_avg?: AccountAvgOrderByAggregateInput
|
|
_max?: AccountMaxOrderByAggregateInput
|
|
_min?: AccountMinOrderByAggregateInput
|
|
_sum?: AccountSumOrderByAggregateInput
|
|
}
|
|
|
|
export type AccountScalarWhereWithAggregatesInput = {
|
|
AND?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
|
|
OR?: AccountScalarWhereWithAggregatesInput[]
|
|
NOT?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Account"> | string
|
|
userId?: StringWithAggregatesFilter<"Account"> | string
|
|
type?: StringWithAggregatesFilter<"Account"> | string
|
|
provider?: StringWithAggregatesFilter<"Account"> | string
|
|
providerAccountId?: StringWithAggregatesFilter<"Account"> | string
|
|
refresh_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
|
|
access_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
|
|
expires_at?: IntNullableWithAggregatesFilter<"Account"> | number | null
|
|
token_type?: StringNullableWithAggregatesFilter<"Account"> | string | null
|
|
scope?: StringNullableWithAggregatesFilter<"Account"> | string | null
|
|
id_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
|
|
session_state?: StringNullableWithAggregatesFilter<"Account"> | string | null
|
|
}
|
|
|
|
export type SessionWhereInput = {
|
|
AND?: SessionWhereInput | SessionWhereInput[]
|
|
OR?: SessionWhereInput[]
|
|
NOT?: SessionWhereInput | SessionWhereInput[]
|
|
id?: StringFilter<"Session"> | string
|
|
sessionToken?: StringFilter<"Session"> | string
|
|
userId?: StringFilter<"Session"> | string
|
|
expires?: DateTimeFilter<"Session"> | Date | string
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
}
|
|
|
|
export type SessionOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
sessionToken?: SortOrder
|
|
userId?: SortOrder
|
|
expires?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
}
|
|
|
|
export type SessionWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
sessionToken?: string
|
|
AND?: SessionWhereInput | SessionWhereInput[]
|
|
OR?: SessionWhereInput[]
|
|
NOT?: SessionWhereInput | SessionWhereInput[]
|
|
userId?: StringFilter<"Session"> | string
|
|
expires?: DateTimeFilter<"Session"> | Date | string
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
}, "id" | "sessionToken">
|
|
|
|
export type SessionOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
sessionToken?: SortOrder
|
|
userId?: SortOrder
|
|
expires?: SortOrder
|
|
_count?: SessionCountOrderByAggregateInput
|
|
_max?: SessionMaxOrderByAggregateInput
|
|
_min?: SessionMinOrderByAggregateInput
|
|
}
|
|
|
|
export type SessionScalarWhereWithAggregatesInput = {
|
|
AND?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
|
|
OR?: SessionScalarWhereWithAggregatesInput[]
|
|
NOT?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Session"> | string
|
|
sessionToken?: StringWithAggregatesFilter<"Session"> | string
|
|
userId?: StringWithAggregatesFilter<"Session"> | string
|
|
expires?: DateTimeWithAggregatesFilter<"Session"> | Date | string
|
|
}
|
|
|
|
export type VerificationTokenWhereInput = {
|
|
AND?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
|
|
OR?: VerificationTokenWhereInput[]
|
|
NOT?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
|
|
identifier?: StringFilter<"VerificationToken"> | string
|
|
token?: StringFilter<"VerificationToken"> | string
|
|
expires?: DateTimeFilter<"VerificationToken"> | Date | string
|
|
}
|
|
|
|
export type VerificationTokenOrderByWithRelationInput = {
|
|
identifier?: SortOrder
|
|
token?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type VerificationTokenWhereUniqueInput = Prisma.AtLeast<{
|
|
token?: string
|
|
identifier_token?: VerificationTokenIdentifierTokenCompoundUniqueInput
|
|
AND?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
|
|
OR?: VerificationTokenWhereInput[]
|
|
NOT?: VerificationTokenWhereInput | VerificationTokenWhereInput[]
|
|
identifier?: StringFilter<"VerificationToken"> | string
|
|
expires?: DateTimeFilter<"VerificationToken"> | Date | string
|
|
}, "token" | "identifier_token">
|
|
|
|
export type VerificationTokenOrderByWithAggregationInput = {
|
|
identifier?: SortOrder
|
|
token?: SortOrder
|
|
expires?: SortOrder
|
|
_count?: VerificationTokenCountOrderByAggregateInput
|
|
_max?: VerificationTokenMaxOrderByAggregateInput
|
|
_min?: VerificationTokenMinOrderByAggregateInput
|
|
}
|
|
|
|
export type VerificationTokenScalarWhereWithAggregatesInput = {
|
|
AND?: VerificationTokenScalarWhereWithAggregatesInput | VerificationTokenScalarWhereWithAggregatesInput[]
|
|
OR?: VerificationTokenScalarWhereWithAggregatesInput[]
|
|
NOT?: VerificationTokenScalarWhereWithAggregatesInput | VerificationTokenScalarWhereWithAggregatesInput[]
|
|
identifier?: StringWithAggregatesFilter<"VerificationToken"> | string
|
|
token?: StringWithAggregatesFilter<"VerificationToken"> | string
|
|
expires?: DateTimeWithAggregatesFilter<"VerificationToken"> | Date | string
|
|
}
|
|
|
|
export type CourseWhereInput = {
|
|
AND?: CourseWhereInput | CourseWhereInput[]
|
|
OR?: CourseWhereInput[]
|
|
NOT?: CourseWhereInput | CourseWhereInput[]
|
|
id?: StringFilter<"Course"> | string
|
|
slug?: StringFilter<"Course"> | string
|
|
category?: EnumCourseCategoryFilter<"Course"> | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFilter<"Course"> | $Enums.CourseLevel
|
|
thumbnailUrl?: StringNullableFilter<"Course"> | string | null
|
|
published?: BoolFilter<"Course"> | boolean
|
|
order?: IntFilter<"Course"> | number
|
|
createdAt?: DateTimeFilter<"Course"> | Date | string
|
|
titleFr?: StringFilter<"Course"> | string
|
|
titleEn?: StringFilter<"Course"> | string
|
|
titleEs?: StringFilter<"Course"> | string
|
|
descFr?: StringFilter<"Course"> | string
|
|
descEn?: StringFilter<"Course"> | string
|
|
descEs?: StringFilter<"Course"> | string
|
|
modules?: ModuleListRelationFilter
|
|
enrollments?: EnrollmentListRelationFilter
|
|
certificates?: CertificateListRelationFilter
|
|
}
|
|
|
|
export type CourseOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
slug?: SortOrder
|
|
category?: SortOrder
|
|
level?: SortOrder
|
|
thumbnailUrl?: SortOrderInput | SortOrder
|
|
published?: SortOrder
|
|
order?: SortOrder
|
|
createdAt?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
descFr?: SortOrder
|
|
descEn?: SortOrder
|
|
descEs?: SortOrder
|
|
modules?: ModuleOrderByRelationAggregateInput
|
|
enrollments?: EnrollmentOrderByRelationAggregateInput
|
|
certificates?: CertificateOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type CourseWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
slug?: string
|
|
AND?: CourseWhereInput | CourseWhereInput[]
|
|
OR?: CourseWhereInput[]
|
|
NOT?: CourseWhereInput | CourseWhereInput[]
|
|
category?: EnumCourseCategoryFilter<"Course"> | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFilter<"Course"> | $Enums.CourseLevel
|
|
thumbnailUrl?: StringNullableFilter<"Course"> | string | null
|
|
published?: BoolFilter<"Course"> | boolean
|
|
order?: IntFilter<"Course"> | number
|
|
createdAt?: DateTimeFilter<"Course"> | Date | string
|
|
titleFr?: StringFilter<"Course"> | string
|
|
titleEn?: StringFilter<"Course"> | string
|
|
titleEs?: StringFilter<"Course"> | string
|
|
descFr?: StringFilter<"Course"> | string
|
|
descEn?: StringFilter<"Course"> | string
|
|
descEs?: StringFilter<"Course"> | string
|
|
modules?: ModuleListRelationFilter
|
|
enrollments?: EnrollmentListRelationFilter
|
|
certificates?: CertificateListRelationFilter
|
|
}, "id" | "slug">
|
|
|
|
export type CourseOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
slug?: SortOrder
|
|
category?: SortOrder
|
|
level?: SortOrder
|
|
thumbnailUrl?: SortOrderInput | SortOrder
|
|
published?: SortOrder
|
|
order?: SortOrder
|
|
createdAt?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
descFr?: SortOrder
|
|
descEn?: SortOrder
|
|
descEs?: SortOrder
|
|
_count?: CourseCountOrderByAggregateInput
|
|
_avg?: CourseAvgOrderByAggregateInput
|
|
_max?: CourseMaxOrderByAggregateInput
|
|
_min?: CourseMinOrderByAggregateInput
|
|
_sum?: CourseSumOrderByAggregateInput
|
|
}
|
|
|
|
export type CourseScalarWhereWithAggregatesInput = {
|
|
AND?: CourseScalarWhereWithAggregatesInput | CourseScalarWhereWithAggregatesInput[]
|
|
OR?: CourseScalarWhereWithAggregatesInput[]
|
|
NOT?: CourseScalarWhereWithAggregatesInput | CourseScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Course"> | string
|
|
slug?: StringWithAggregatesFilter<"Course"> | string
|
|
category?: EnumCourseCategoryWithAggregatesFilter<"Course"> | $Enums.CourseCategory
|
|
level?: EnumCourseLevelWithAggregatesFilter<"Course"> | $Enums.CourseLevel
|
|
thumbnailUrl?: StringNullableWithAggregatesFilter<"Course"> | string | null
|
|
published?: BoolWithAggregatesFilter<"Course"> | boolean
|
|
order?: IntWithAggregatesFilter<"Course"> | number
|
|
createdAt?: DateTimeWithAggregatesFilter<"Course"> | Date | string
|
|
titleFr?: StringWithAggregatesFilter<"Course"> | string
|
|
titleEn?: StringWithAggregatesFilter<"Course"> | string
|
|
titleEs?: StringWithAggregatesFilter<"Course"> | string
|
|
descFr?: StringWithAggregatesFilter<"Course"> | string
|
|
descEn?: StringWithAggregatesFilter<"Course"> | string
|
|
descEs?: StringWithAggregatesFilter<"Course"> | string
|
|
}
|
|
|
|
export type ModuleWhereInput = {
|
|
AND?: ModuleWhereInput | ModuleWhereInput[]
|
|
OR?: ModuleWhereInput[]
|
|
NOT?: ModuleWhereInput | ModuleWhereInput[]
|
|
id?: StringFilter<"Module"> | string
|
|
courseId?: StringFilter<"Module"> | string
|
|
order?: IntFilter<"Module"> | number
|
|
titleFr?: StringFilter<"Module"> | string
|
|
titleEn?: StringFilter<"Module"> | string
|
|
titleEs?: StringFilter<"Module"> | string
|
|
course?: XOR<CourseScalarRelationFilter, CourseWhereInput>
|
|
lessons?: LessonListRelationFilter
|
|
quiz?: XOR<QuizNullableScalarRelationFilter, QuizWhereInput> | null
|
|
}
|
|
|
|
export type ModuleOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
courseId?: SortOrder
|
|
order?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
course?: CourseOrderByWithRelationInput
|
|
lessons?: LessonOrderByRelationAggregateInput
|
|
quiz?: QuizOrderByWithRelationInput
|
|
}
|
|
|
|
export type ModuleWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: ModuleWhereInput | ModuleWhereInput[]
|
|
OR?: ModuleWhereInput[]
|
|
NOT?: ModuleWhereInput | ModuleWhereInput[]
|
|
courseId?: StringFilter<"Module"> | string
|
|
order?: IntFilter<"Module"> | number
|
|
titleFr?: StringFilter<"Module"> | string
|
|
titleEn?: StringFilter<"Module"> | string
|
|
titleEs?: StringFilter<"Module"> | string
|
|
course?: XOR<CourseScalarRelationFilter, CourseWhereInput>
|
|
lessons?: LessonListRelationFilter
|
|
quiz?: XOR<QuizNullableScalarRelationFilter, QuizWhereInput> | null
|
|
}, "id">
|
|
|
|
export type ModuleOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
courseId?: SortOrder
|
|
order?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
_count?: ModuleCountOrderByAggregateInput
|
|
_avg?: ModuleAvgOrderByAggregateInput
|
|
_max?: ModuleMaxOrderByAggregateInput
|
|
_min?: ModuleMinOrderByAggregateInput
|
|
_sum?: ModuleSumOrderByAggregateInput
|
|
}
|
|
|
|
export type ModuleScalarWhereWithAggregatesInput = {
|
|
AND?: ModuleScalarWhereWithAggregatesInput | ModuleScalarWhereWithAggregatesInput[]
|
|
OR?: ModuleScalarWhereWithAggregatesInput[]
|
|
NOT?: ModuleScalarWhereWithAggregatesInput | ModuleScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Module"> | string
|
|
courseId?: StringWithAggregatesFilter<"Module"> | string
|
|
order?: IntWithAggregatesFilter<"Module"> | number
|
|
titleFr?: StringWithAggregatesFilter<"Module"> | string
|
|
titleEn?: StringWithAggregatesFilter<"Module"> | string
|
|
titleEs?: StringWithAggregatesFilter<"Module"> | string
|
|
}
|
|
|
|
export type LessonWhereInput = {
|
|
AND?: LessonWhereInput | LessonWhereInput[]
|
|
OR?: LessonWhereInput[]
|
|
NOT?: LessonWhereInput | LessonWhereInput[]
|
|
id?: StringFilter<"Lesson"> | string
|
|
moduleId?: StringFilter<"Lesson"> | string
|
|
order?: IntFilter<"Lesson"> | number
|
|
type?: EnumLessonTypeFilter<"Lesson"> | $Enums.LessonType
|
|
videoUrl?: StringNullableFilter<"Lesson"> | string | null
|
|
duration?: IntNullableFilter<"Lesson"> | number | null
|
|
titleFr?: StringFilter<"Lesson"> | string
|
|
titleEn?: StringFilter<"Lesson"> | string
|
|
titleEs?: StringFilter<"Lesson"> | string
|
|
contentFr?: StringNullableFilter<"Lesson"> | string | null
|
|
contentEn?: StringNullableFilter<"Lesson"> | string | null
|
|
contentEs?: StringNullableFilter<"Lesson"> | string | null
|
|
module?: XOR<ModuleScalarRelationFilter, ModuleWhereInput>
|
|
lessonProgress?: LessonProgressListRelationFilter
|
|
}
|
|
|
|
export type LessonOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
order?: SortOrder
|
|
type?: SortOrder
|
|
videoUrl?: SortOrderInput | SortOrder
|
|
duration?: SortOrderInput | SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
contentFr?: SortOrderInput | SortOrder
|
|
contentEn?: SortOrderInput | SortOrder
|
|
contentEs?: SortOrderInput | SortOrder
|
|
module?: ModuleOrderByWithRelationInput
|
|
lessonProgress?: LessonProgressOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type LessonWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: LessonWhereInput | LessonWhereInput[]
|
|
OR?: LessonWhereInput[]
|
|
NOT?: LessonWhereInput | LessonWhereInput[]
|
|
moduleId?: StringFilter<"Lesson"> | string
|
|
order?: IntFilter<"Lesson"> | number
|
|
type?: EnumLessonTypeFilter<"Lesson"> | $Enums.LessonType
|
|
videoUrl?: StringNullableFilter<"Lesson"> | string | null
|
|
duration?: IntNullableFilter<"Lesson"> | number | null
|
|
titleFr?: StringFilter<"Lesson"> | string
|
|
titleEn?: StringFilter<"Lesson"> | string
|
|
titleEs?: StringFilter<"Lesson"> | string
|
|
contentFr?: StringNullableFilter<"Lesson"> | string | null
|
|
contentEn?: StringNullableFilter<"Lesson"> | string | null
|
|
contentEs?: StringNullableFilter<"Lesson"> | string | null
|
|
module?: XOR<ModuleScalarRelationFilter, ModuleWhereInput>
|
|
lessonProgress?: LessonProgressListRelationFilter
|
|
}, "id">
|
|
|
|
export type LessonOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
order?: SortOrder
|
|
type?: SortOrder
|
|
videoUrl?: SortOrderInput | SortOrder
|
|
duration?: SortOrderInput | SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
contentFr?: SortOrderInput | SortOrder
|
|
contentEn?: SortOrderInput | SortOrder
|
|
contentEs?: SortOrderInput | SortOrder
|
|
_count?: LessonCountOrderByAggregateInput
|
|
_avg?: LessonAvgOrderByAggregateInput
|
|
_max?: LessonMaxOrderByAggregateInput
|
|
_min?: LessonMinOrderByAggregateInput
|
|
_sum?: LessonSumOrderByAggregateInput
|
|
}
|
|
|
|
export type LessonScalarWhereWithAggregatesInput = {
|
|
AND?: LessonScalarWhereWithAggregatesInput | LessonScalarWhereWithAggregatesInput[]
|
|
OR?: LessonScalarWhereWithAggregatesInput[]
|
|
NOT?: LessonScalarWhereWithAggregatesInput | LessonScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Lesson"> | string
|
|
moduleId?: StringWithAggregatesFilter<"Lesson"> | string
|
|
order?: IntWithAggregatesFilter<"Lesson"> | number
|
|
type?: EnumLessonTypeWithAggregatesFilter<"Lesson"> | $Enums.LessonType
|
|
videoUrl?: StringNullableWithAggregatesFilter<"Lesson"> | string | null
|
|
duration?: IntNullableWithAggregatesFilter<"Lesson"> | number | null
|
|
titleFr?: StringWithAggregatesFilter<"Lesson"> | string
|
|
titleEn?: StringWithAggregatesFilter<"Lesson"> | string
|
|
titleEs?: StringWithAggregatesFilter<"Lesson"> | string
|
|
contentFr?: StringNullableWithAggregatesFilter<"Lesson"> | string | null
|
|
contentEn?: StringNullableWithAggregatesFilter<"Lesson"> | string | null
|
|
contentEs?: StringNullableWithAggregatesFilter<"Lesson"> | string | null
|
|
}
|
|
|
|
export type QuizWhereInput = {
|
|
AND?: QuizWhereInput | QuizWhereInput[]
|
|
OR?: QuizWhereInput[]
|
|
NOT?: QuizWhereInput | QuizWhereInput[]
|
|
id?: StringFilter<"Quiz"> | string
|
|
moduleId?: StringFilter<"Quiz"> | string
|
|
passMark?: IntFilter<"Quiz"> | number
|
|
module?: XOR<ModuleScalarRelationFilter, ModuleWhereInput>
|
|
questions?: QuestionListRelationFilter
|
|
attempts?: QuizAttemptListRelationFilter
|
|
}
|
|
|
|
export type QuizOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
passMark?: SortOrder
|
|
module?: ModuleOrderByWithRelationInput
|
|
questions?: QuestionOrderByRelationAggregateInput
|
|
attempts?: QuizAttemptOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type QuizWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
moduleId?: string
|
|
AND?: QuizWhereInput | QuizWhereInput[]
|
|
OR?: QuizWhereInput[]
|
|
NOT?: QuizWhereInput | QuizWhereInput[]
|
|
passMark?: IntFilter<"Quiz"> | number
|
|
module?: XOR<ModuleScalarRelationFilter, ModuleWhereInput>
|
|
questions?: QuestionListRelationFilter
|
|
attempts?: QuizAttemptListRelationFilter
|
|
}, "id" | "moduleId">
|
|
|
|
export type QuizOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
passMark?: SortOrder
|
|
_count?: QuizCountOrderByAggregateInput
|
|
_avg?: QuizAvgOrderByAggregateInput
|
|
_max?: QuizMaxOrderByAggregateInput
|
|
_min?: QuizMinOrderByAggregateInput
|
|
_sum?: QuizSumOrderByAggregateInput
|
|
}
|
|
|
|
export type QuizScalarWhereWithAggregatesInput = {
|
|
AND?: QuizScalarWhereWithAggregatesInput | QuizScalarWhereWithAggregatesInput[]
|
|
OR?: QuizScalarWhereWithAggregatesInput[]
|
|
NOT?: QuizScalarWhereWithAggregatesInput | QuizScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Quiz"> | string
|
|
moduleId?: StringWithAggregatesFilter<"Quiz"> | string
|
|
passMark?: IntWithAggregatesFilter<"Quiz"> | number
|
|
}
|
|
|
|
export type QuestionWhereInput = {
|
|
AND?: QuestionWhereInput | QuestionWhereInput[]
|
|
OR?: QuestionWhereInput[]
|
|
NOT?: QuestionWhereInput | QuestionWhereInput[]
|
|
id?: StringFilter<"Question"> | string
|
|
quizId?: StringFilter<"Question"> | string
|
|
order?: IntFilter<"Question"> | number
|
|
textFr?: StringFilter<"Question"> | string
|
|
textEn?: StringFilter<"Question"> | string
|
|
textEs?: StringFilter<"Question"> | string
|
|
optionsFr?: StringNullableListFilter<"Question">
|
|
optionsEn?: StringNullableListFilter<"Question">
|
|
optionsEs?: StringNullableListFilter<"Question">
|
|
correctIndex?: IntFilter<"Question"> | number
|
|
quiz?: XOR<QuizScalarRelationFilter, QuizWhereInput>
|
|
}
|
|
|
|
export type QuestionOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
quizId?: SortOrder
|
|
order?: SortOrder
|
|
textFr?: SortOrder
|
|
textEn?: SortOrder
|
|
textEs?: SortOrder
|
|
optionsFr?: SortOrder
|
|
optionsEn?: SortOrder
|
|
optionsEs?: SortOrder
|
|
correctIndex?: SortOrder
|
|
quiz?: QuizOrderByWithRelationInput
|
|
}
|
|
|
|
export type QuestionWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: QuestionWhereInput | QuestionWhereInput[]
|
|
OR?: QuestionWhereInput[]
|
|
NOT?: QuestionWhereInput | QuestionWhereInput[]
|
|
quizId?: StringFilter<"Question"> | string
|
|
order?: IntFilter<"Question"> | number
|
|
textFr?: StringFilter<"Question"> | string
|
|
textEn?: StringFilter<"Question"> | string
|
|
textEs?: StringFilter<"Question"> | string
|
|
optionsFr?: StringNullableListFilter<"Question">
|
|
optionsEn?: StringNullableListFilter<"Question">
|
|
optionsEs?: StringNullableListFilter<"Question">
|
|
correctIndex?: IntFilter<"Question"> | number
|
|
quiz?: XOR<QuizScalarRelationFilter, QuizWhereInput>
|
|
}, "id">
|
|
|
|
export type QuestionOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
quizId?: SortOrder
|
|
order?: SortOrder
|
|
textFr?: SortOrder
|
|
textEn?: SortOrder
|
|
textEs?: SortOrder
|
|
optionsFr?: SortOrder
|
|
optionsEn?: SortOrder
|
|
optionsEs?: SortOrder
|
|
correctIndex?: SortOrder
|
|
_count?: QuestionCountOrderByAggregateInput
|
|
_avg?: QuestionAvgOrderByAggregateInput
|
|
_max?: QuestionMaxOrderByAggregateInput
|
|
_min?: QuestionMinOrderByAggregateInput
|
|
_sum?: QuestionSumOrderByAggregateInput
|
|
}
|
|
|
|
export type QuestionScalarWhereWithAggregatesInput = {
|
|
AND?: QuestionScalarWhereWithAggregatesInput | QuestionScalarWhereWithAggregatesInput[]
|
|
OR?: QuestionScalarWhereWithAggregatesInput[]
|
|
NOT?: QuestionScalarWhereWithAggregatesInput | QuestionScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Question"> | string
|
|
quizId?: StringWithAggregatesFilter<"Question"> | string
|
|
order?: IntWithAggregatesFilter<"Question"> | number
|
|
textFr?: StringWithAggregatesFilter<"Question"> | string
|
|
textEn?: StringWithAggregatesFilter<"Question"> | string
|
|
textEs?: StringWithAggregatesFilter<"Question"> | string
|
|
optionsFr?: StringNullableListFilter<"Question">
|
|
optionsEn?: StringNullableListFilter<"Question">
|
|
optionsEs?: StringNullableListFilter<"Question">
|
|
correctIndex?: IntWithAggregatesFilter<"Question"> | number
|
|
}
|
|
|
|
export type EnrollmentWhereInput = {
|
|
AND?: EnrollmentWhereInput | EnrollmentWhereInput[]
|
|
OR?: EnrollmentWhereInput[]
|
|
NOT?: EnrollmentWhereInput | EnrollmentWhereInput[]
|
|
id?: StringFilter<"Enrollment"> | string
|
|
userId?: StringFilter<"Enrollment"> | string
|
|
courseId?: StringFilter<"Enrollment"> | string
|
|
enrolledAt?: DateTimeFilter<"Enrollment"> | Date | string
|
|
completedAt?: DateTimeNullableFilter<"Enrollment"> | Date | string | null
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
course?: XOR<CourseScalarRelationFilter, CourseWhereInput>
|
|
}
|
|
|
|
export type EnrollmentOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
enrolledAt?: SortOrder
|
|
completedAt?: SortOrderInput | SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
course?: CourseOrderByWithRelationInput
|
|
}
|
|
|
|
export type EnrollmentWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
userId_courseId?: EnrollmentUserIdCourseIdCompoundUniqueInput
|
|
AND?: EnrollmentWhereInput | EnrollmentWhereInput[]
|
|
OR?: EnrollmentWhereInput[]
|
|
NOT?: EnrollmentWhereInput | EnrollmentWhereInput[]
|
|
userId?: StringFilter<"Enrollment"> | string
|
|
courseId?: StringFilter<"Enrollment"> | string
|
|
enrolledAt?: DateTimeFilter<"Enrollment"> | Date | string
|
|
completedAt?: DateTimeNullableFilter<"Enrollment"> | Date | string | null
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
course?: XOR<CourseScalarRelationFilter, CourseWhereInput>
|
|
}, "id" | "userId_courseId">
|
|
|
|
export type EnrollmentOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
enrolledAt?: SortOrder
|
|
completedAt?: SortOrderInput | SortOrder
|
|
_count?: EnrollmentCountOrderByAggregateInput
|
|
_max?: EnrollmentMaxOrderByAggregateInput
|
|
_min?: EnrollmentMinOrderByAggregateInput
|
|
}
|
|
|
|
export type EnrollmentScalarWhereWithAggregatesInput = {
|
|
AND?: EnrollmentScalarWhereWithAggregatesInput | EnrollmentScalarWhereWithAggregatesInput[]
|
|
OR?: EnrollmentScalarWhereWithAggregatesInput[]
|
|
NOT?: EnrollmentScalarWhereWithAggregatesInput | EnrollmentScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Enrollment"> | string
|
|
userId?: StringWithAggregatesFilter<"Enrollment"> | string
|
|
courseId?: StringWithAggregatesFilter<"Enrollment"> | string
|
|
enrolledAt?: DateTimeWithAggregatesFilter<"Enrollment"> | Date | string
|
|
completedAt?: DateTimeNullableWithAggregatesFilter<"Enrollment"> | Date | string | null
|
|
}
|
|
|
|
export type LessonProgressWhereInput = {
|
|
AND?: LessonProgressWhereInput | LessonProgressWhereInput[]
|
|
OR?: LessonProgressWhereInput[]
|
|
NOT?: LessonProgressWhereInput | LessonProgressWhereInput[]
|
|
id?: StringFilter<"LessonProgress"> | string
|
|
userId?: StringFilter<"LessonProgress"> | string
|
|
lessonId?: StringFilter<"LessonProgress"> | string
|
|
completedAt?: DateTimeFilter<"LessonProgress"> | Date | string
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
lesson?: XOR<LessonScalarRelationFilter, LessonWhereInput>
|
|
}
|
|
|
|
export type LessonProgressOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
lessonId?: SortOrder
|
|
completedAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
lesson?: LessonOrderByWithRelationInput
|
|
}
|
|
|
|
export type LessonProgressWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
userId_lessonId?: LessonProgressUserIdLessonIdCompoundUniqueInput
|
|
AND?: LessonProgressWhereInput | LessonProgressWhereInput[]
|
|
OR?: LessonProgressWhereInput[]
|
|
NOT?: LessonProgressWhereInput | LessonProgressWhereInput[]
|
|
userId?: StringFilter<"LessonProgress"> | string
|
|
lessonId?: StringFilter<"LessonProgress"> | string
|
|
completedAt?: DateTimeFilter<"LessonProgress"> | Date | string
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
lesson?: XOR<LessonScalarRelationFilter, LessonWhereInput>
|
|
}, "id" | "userId_lessonId">
|
|
|
|
export type LessonProgressOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
lessonId?: SortOrder
|
|
completedAt?: SortOrder
|
|
_count?: LessonProgressCountOrderByAggregateInput
|
|
_max?: LessonProgressMaxOrderByAggregateInput
|
|
_min?: LessonProgressMinOrderByAggregateInput
|
|
}
|
|
|
|
export type LessonProgressScalarWhereWithAggregatesInput = {
|
|
AND?: LessonProgressScalarWhereWithAggregatesInput | LessonProgressScalarWhereWithAggregatesInput[]
|
|
OR?: LessonProgressScalarWhereWithAggregatesInput[]
|
|
NOT?: LessonProgressScalarWhereWithAggregatesInput | LessonProgressScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"LessonProgress"> | string
|
|
userId?: StringWithAggregatesFilter<"LessonProgress"> | string
|
|
lessonId?: StringWithAggregatesFilter<"LessonProgress"> | string
|
|
completedAt?: DateTimeWithAggregatesFilter<"LessonProgress"> | Date | string
|
|
}
|
|
|
|
export type QuizAttemptWhereInput = {
|
|
AND?: QuizAttemptWhereInput | QuizAttemptWhereInput[]
|
|
OR?: QuizAttemptWhereInput[]
|
|
NOT?: QuizAttemptWhereInput | QuizAttemptWhereInput[]
|
|
id?: StringFilter<"QuizAttempt"> | string
|
|
userId?: StringFilter<"QuizAttempt"> | string
|
|
quizId?: StringFilter<"QuizAttempt"> | string
|
|
score?: IntFilter<"QuizAttempt"> | number
|
|
passed?: BoolFilter<"QuizAttempt"> | boolean
|
|
answers?: IntNullableListFilter<"QuizAttempt">
|
|
completedAt?: DateTimeFilter<"QuizAttempt"> | Date | string
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
quiz?: XOR<QuizScalarRelationFilter, QuizWhereInput>
|
|
}
|
|
|
|
export type QuizAttemptOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
quizId?: SortOrder
|
|
score?: SortOrder
|
|
passed?: SortOrder
|
|
answers?: SortOrder
|
|
completedAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
quiz?: QuizOrderByWithRelationInput
|
|
}
|
|
|
|
export type QuizAttemptWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: QuizAttemptWhereInput | QuizAttemptWhereInput[]
|
|
OR?: QuizAttemptWhereInput[]
|
|
NOT?: QuizAttemptWhereInput | QuizAttemptWhereInput[]
|
|
userId?: StringFilter<"QuizAttempt"> | string
|
|
quizId?: StringFilter<"QuizAttempt"> | string
|
|
score?: IntFilter<"QuizAttempt"> | number
|
|
passed?: BoolFilter<"QuizAttempt"> | boolean
|
|
answers?: IntNullableListFilter<"QuizAttempt">
|
|
completedAt?: DateTimeFilter<"QuizAttempt"> | Date | string
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
quiz?: XOR<QuizScalarRelationFilter, QuizWhereInput>
|
|
}, "id">
|
|
|
|
export type QuizAttemptOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
quizId?: SortOrder
|
|
score?: SortOrder
|
|
passed?: SortOrder
|
|
answers?: SortOrder
|
|
completedAt?: SortOrder
|
|
_count?: QuizAttemptCountOrderByAggregateInput
|
|
_avg?: QuizAttemptAvgOrderByAggregateInput
|
|
_max?: QuizAttemptMaxOrderByAggregateInput
|
|
_min?: QuizAttemptMinOrderByAggregateInput
|
|
_sum?: QuizAttemptSumOrderByAggregateInput
|
|
}
|
|
|
|
export type QuizAttemptScalarWhereWithAggregatesInput = {
|
|
AND?: QuizAttemptScalarWhereWithAggregatesInput | QuizAttemptScalarWhereWithAggregatesInput[]
|
|
OR?: QuizAttemptScalarWhereWithAggregatesInput[]
|
|
NOT?: QuizAttemptScalarWhereWithAggregatesInput | QuizAttemptScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"QuizAttempt"> | string
|
|
userId?: StringWithAggregatesFilter<"QuizAttempt"> | string
|
|
quizId?: StringWithAggregatesFilter<"QuizAttempt"> | string
|
|
score?: IntWithAggregatesFilter<"QuizAttempt"> | number
|
|
passed?: BoolWithAggregatesFilter<"QuizAttempt"> | boolean
|
|
answers?: IntNullableListFilter<"QuizAttempt">
|
|
completedAt?: DateTimeWithAggregatesFilter<"QuizAttempt"> | Date | string
|
|
}
|
|
|
|
export type CertificateWhereInput = {
|
|
AND?: CertificateWhereInput | CertificateWhereInput[]
|
|
OR?: CertificateWhereInput[]
|
|
NOT?: CertificateWhereInput | CertificateWhereInput[]
|
|
id?: StringFilter<"Certificate"> | string
|
|
userId?: StringFilter<"Certificate"> | string
|
|
courseId?: StringFilter<"Certificate"> | string
|
|
issuedAt?: DateTimeFilter<"Certificate"> | Date | string
|
|
pdfUrl?: StringNullableFilter<"Certificate"> | string | null
|
|
isPaid?: BoolFilter<"Certificate"> | boolean
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
course?: XOR<CourseScalarRelationFilter, CourseWhereInput>
|
|
}
|
|
|
|
export type CertificateOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
issuedAt?: SortOrder
|
|
pdfUrl?: SortOrderInput | SortOrder
|
|
isPaid?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
course?: CourseOrderByWithRelationInput
|
|
}
|
|
|
|
export type CertificateWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
userId_courseId?: CertificateUserIdCourseIdCompoundUniqueInput
|
|
AND?: CertificateWhereInput | CertificateWhereInput[]
|
|
OR?: CertificateWhereInput[]
|
|
NOT?: CertificateWhereInput | CertificateWhereInput[]
|
|
userId?: StringFilter<"Certificate"> | string
|
|
courseId?: StringFilter<"Certificate"> | string
|
|
issuedAt?: DateTimeFilter<"Certificate"> | Date | string
|
|
pdfUrl?: StringNullableFilter<"Certificate"> | string | null
|
|
isPaid?: BoolFilter<"Certificate"> | boolean
|
|
user?: XOR<UserScalarRelationFilter, UserWhereInput>
|
|
course?: XOR<CourseScalarRelationFilter, CourseWhereInput>
|
|
}, "id" | "userId_courseId">
|
|
|
|
export type CertificateOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
issuedAt?: SortOrder
|
|
pdfUrl?: SortOrderInput | SortOrder
|
|
isPaid?: SortOrder
|
|
_count?: CertificateCountOrderByAggregateInput
|
|
_max?: CertificateMaxOrderByAggregateInput
|
|
_min?: CertificateMinOrderByAggregateInput
|
|
}
|
|
|
|
export type CertificateScalarWhereWithAggregatesInput = {
|
|
AND?: CertificateScalarWhereWithAggregatesInput | CertificateScalarWhereWithAggregatesInput[]
|
|
OR?: CertificateScalarWhereWithAggregatesInput[]
|
|
NOT?: CertificateScalarWhereWithAggregatesInput | CertificateScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Certificate"> | string
|
|
userId?: StringWithAggregatesFilter<"Certificate"> | string
|
|
courseId?: StringWithAggregatesFilter<"Certificate"> | string
|
|
issuedAt?: DateTimeWithAggregatesFilter<"Certificate"> | Date | string
|
|
pdfUrl?: StringNullableWithAggregatesFilter<"Certificate"> | string | null
|
|
isPaid?: BoolWithAggregatesFilter<"Certificate"> | boolean
|
|
}
|
|
|
|
export type UserCreateInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountCreateNestedManyWithoutUserInput
|
|
sessions?: SessionCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
|
|
sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptUncheckedCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUncheckedUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserCreateManyInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type UserUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AccountCreateInput = {
|
|
id?: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token?: string | null
|
|
access_token?: string | null
|
|
expires_at?: number | null
|
|
token_type?: string | null
|
|
scope?: string | null
|
|
id_token?: string | null
|
|
session_state?: string | null
|
|
user: UserCreateNestedOneWithoutAccountsInput
|
|
}
|
|
|
|
export type AccountUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token?: string | null
|
|
access_token?: string | null
|
|
expires_at?: number | null
|
|
token_type?: string | null
|
|
scope?: string | null
|
|
id_token?: string | null
|
|
session_state?: string | null
|
|
}
|
|
|
|
export type AccountUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
user?: UserUpdateOneRequiredWithoutAccountsNestedInput
|
|
}
|
|
|
|
export type AccountUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type AccountCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token?: string | null
|
|
access_token?: string | null
|
|
expires_at?: number | null
|
|
token_type?: string | null
|
|
scope?: string | null
|
|
id_token?: string | null
|
|
session_state?: string | null
|
|
}
|
|
|
|
export type AccountUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type AccountUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type SessionCreateInput = {
|
|
id?: string
|
|
sessionToken: string
|
|
expires: Date | string
|
|
user: UserCreateNestedOneWithoutSessionsInput
|
|
}
|
|
|
|
export type SessionUncheckedCreateInput = {
|
|
id?: string
|
|
sessionToken: string
|
|
userId: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type SessionUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutSessionsNestedInput
|
|
}
|
|
|
|
export type SessionUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SessionCreateManyInput = {
|
|
id?: string
|
|
sessionToken: string
|
|
userId: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type SessionUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SessionUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VerificationTokenCreateInput = {
|
|
identifier: string
|
|
token: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type VerificationTokenUncheckedCreateInput = {
|
|
identifier: string
|
|
token: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type VerificationTokenUpdateInput = {
|
|
identifier?: StringFieldUpdateOperationsInput | string
|
|
token?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VerificationTokenUncheckedUpdateInput = {
|
|
identifier?: StringFieldUpdateOperationsInput | string
|
|
token?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VerificationTokenCreateManyInput = {
|
|
identifier: string
|
|
token: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type VerificationTokenUpdateManyMutationInput = {
|
|
identifier?: StringFieldUpdateOperationsInput | string
|
|
token?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VerificationTokenUncheckedUpdateManyInput = {
|
|
identifier?: StringFieldUpdateOperationsInput | string
|
|
token?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type CourseCreateInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
modules?: ModuleCreateNestedManyWithoutCourseInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutCourseInput
|
|
certificates?: CertificateCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseUncheckedCreateInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
modules?: ModuleUncheckedCreateNestedManyWithoutCourseInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutCourseInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
modules?: ModuleUpdateManyWithoutCourseNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutCourseNestedInput
|
|
certificates?: CertificateUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type CourseUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
modules?: ModuleUncheckedUpdateManyWithoutCourseNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutCourseNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type CourseCreateManyInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
}
|
|
|
|
export type CourseUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type CourseUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type ModuleCreateInput = {
|
|
id?: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
course: CourseCreateNestedOneWithoutModulesInput
|
|
lessons?: LessonCreateNestedManyWithoutModuleInput
|
|
quiz?: QuizCreateNestedOneWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleUncheckedCreateInput = {
|
|
id?: string
|
|
courseId: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
lessons?: LessonUncheckedCreateNestedManyWithoutModuleInput
|
|
quiz?: QuizUncheckedCreateNestedOneWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
course?: CourseUpdateOneRequiredWithoutModulesNestedInput
|
|
lessons?: LessonUpdateManyWithoutModuleNestedInput
|
|
quiz?: QuizUpdateOneWithoutModuleNestedInput
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
lessons?: LessonUncheckedUpdateManyWithoutModuleNestedInput
|
|
quiz?: QuizUncheckedUpdateOneWithoutModuleNestedInput
|
|
}
|
|
|
|
export type ModuleCreateManyInput = {
|
|
id?: string
|
|
courseId: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
}
|
|
|
|
export type ModuleUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type LessonCreateInput = {
|
|
id?: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
module: ModuleCreateNestedOneWithoutLessonsInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutLessonInput
|
|
}
|
|
|
|
export type LessonUncheckedCreateInput = {
|
|
id?: string
|
|
moduleId: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutLessonInput
|
|
}
|
|
|
|
export type LessonUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
module?: ModuleUpdateOneRequiredWithoutLessonsNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutLessonNestedInput
|
|
}
|
|
|
|
export type LessonUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutLessonNestedInput
|
|
}
|
|
|
|
export type LessonCreateManyInput = {
|
|
id?: string
|
|
moduleId: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
}
|
|
|
|
export type LessonUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type LessonUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type QuizCreateInput = {
|
|
id?: string
|
|
passMark?: number
|
|
module: ModuleCreateNestedOneWithoutQuizInput
|
|
questions?: QuestionCreateNestedManyWithoutQuizInput
|
|
attempts?: QuizAttemptCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizUncheckedCreateInput = {
|
|
id?: string
|
|
moduleId: string
|
|
passMark?: number
|
|
questions?: QuestionUncheckedCreateNestedManyWithoutQuizInput
|
|
attempts?: QuizAttemptUncheckedCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
module?: ModuleUpdateOneRequiredWithoutQuizNestedInput
|
|
questions?: QuestionUpdateManyWithoutQuizNestedInput
|
|
attempts?: QuizAttemptUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type QuizUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
questions?: QuestionUncheckedUpdateManyWithoutQuizNestedInput
|
|
attempts?: QuizAttemptUncheckedUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type QuizCreateManyInput = {
|
|
id?: string
|
|
moduleId: string
|
|
passMark?: number
|
|
}
|
|
|
|
export type QuizUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuizUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuestionCreateInput = {
|
|
id?: string
|
|
order?: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr?: QuestionCreateoptionsFrInput | string[]
|
|
optionsEn?: QuestionCreateoptionsEnInput | string[]
|
|
optionsEs?: QuestionCreateoptionsEsInput | string[]
|
|
correctIndex: number
|
|
quiz: QuizCreateNestedOneWithoutQuestionsInput
|
|
}
|
|
|
|
export type QuestionUncheckedCreateInput = {
|
|
id?: string
|
|
quizId: string
|
|
order?: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr?: QuestionCreateoptionsFrInput | string[]
|
|
optionsEn?: QuestionCreateoptionsEnInput | string[]
|
|
optionsEs?: QuestionCreateoptionsEsInput | string[]
|
|
correctIndex: number
|
|
}
|
|
|
|
export type QuestionUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
quiz?: QuizUpdateOneRequiredWithoutQuestionsNestedInput
|
|
}
|
|
|
|
export type QuestionUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
quizId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuestionCreateManyInput = {
|
|
id?: string
|
|
quizId: string
|
|
order?: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr?: QuestionCreateoptionsFrInput | string[]
|
|
optionsEn?: QuestionCreateoptionsEnInput | string[]
|
|
optionsEs?: QuestionCreateoptionsEsInput | string[]
|
|
correctIndex: number
|
|
}
|
|
|
|
export type QuestionUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuestionUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
quizId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type EnrollmentCreateInput = {
|
|
id?: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
user: UserCreateNestedOneWithoutEnrollmentsInput
|
|
course: CourseCreateNestedOneWithoutEnrollmentsInput
|
|
}
|
|
|
|
export type EnrollmentUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
courseId: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
}
|
|
|
|
export type EnrollmentUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
user?: UserUpdateOneRequiredWithoutEnrollmentsNestedInput
|
|
course?: CourseUpdateOneRequiredWithoutEnrollmentsNestedInput
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type EnrollmentCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
courseId: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
}
|
|
|
|
export type EnrollmentUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type LessonProgressCreateInput = {
|
|
id?: string
|
|
completedAt?: Date | string
|
|
user: UserCreateNestedOneWithoutLessonProgressInput
|
|
lesson: LessonCreateNestedOneWithoutLessonProgressInput
|
|
}
|
|
|
|
export type LessonProgressUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
lessonId: string
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type LessonProgressUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutLessonProgressNestedInput
|
|
lesson?: LessonUpdateOneRequiredWithoutLessonProgressNestedInput
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
lessonId?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LessonProgressCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
lessonId: string
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type LessonProgressUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
lessonId?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuizAttemptCreateInput = {
|
|
id?: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
user: UserCreateNestedOneWithoutQuizAttemptsInput
|
|
quiz: QuizCreateNestedOneWithoutAttemptsInput
|
|
}
|
|
|
|
export type QuizAttemptUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
quizId: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type QuizAttemptUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutQuizAttemptsNestedInput
|
|
quiz?: QuizUpdateOneRequiredWithoutAttemptsNestedInput
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
quizId?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuizAttemptCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
quizId: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type QuizAttemptUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
quizId?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type CertificateCreateInput = {
|
|
id?: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
user: UserCreateNestedOneWithoutCertificatesInput
|
|
course: CourseCreateNestedOneWithoutCertificatesInput
|
|
}
|
|
|
|
export type CertificateUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
courseId: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type CertificateUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
user?: UserUpdateOneRequiredWithoutCertificatesNestedInput
|
|
course?: CourseUpdateOneRequiredWithoutCertificatesNestedInput
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type CertificateCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
courseId: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type CertificateUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type StringFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringFilter<$PrismaModel> | string
|
|
}
|
|
|
|
export type StringNullableFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringNullableFilter<$PrismaModel> | string | null
|
|
}
|
|
|
|
export type 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 EnumRoleFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
|
|
}
|
|
|
|
export type DateTimeFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeFilter<$PrismaModel> | Date | string
|
|
}
|
|
|
|
export type AccountListRelationFilter = {
|
|
every?: AccountWhereInput
|
|
some?: AccountWhereInput
|
|
none?: AccountWhereInput
|
|
}
|
|
|
|
export type SessionListRelationFilter = {
|
|
every?: SessionWhereInput
|
|
some?: SessionWhereInput
|
|
none?: SessionWhereInput
|
|
}
|
|
|
|
export type EnrollmentListRelationFilter = {
|
|
every?: EnrollmentWhereInput
|
|
some?: EnrollmentWhereInput
|
|
none?: EnrollmentWhereInput
|
|
}
|
|
|
|
export type LessonProgressListRelationFilter = {
|
|
every?: LessonProgressWhereInput
|
|
some?: LessonProgressWhereInput
|
|
none?: LessonProgressWhereInput
|
|
}
|
|
|
|
export type QuizAttemptListRelationFilter = {
|
|
every?: QuizAttemptWhereInput
|
|
some?: QuizAttemptWhereInput
|
|
none?: QuizAttemptWhereInput
|
|
}
|
|
|
|
export type CertificateListRelationFilter = {
|
|
every?: CertificateWhereInput
|
|
some?: CertificateWhereInput
|
|
none?: CertificateWhereInput
|
|
}
|
|
|
|
export type SortOrderInput = {
|
|
sort: SortOrder
|
|
nulls?: NullsOrder
|
|
}
|
|
|
|
export type AccountOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type SessionOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type EnrollmentOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type LessonProgressOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type QuizAttemptOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type CertificateOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type UserCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
email?: SortOrder
|
|
name?: SortOrder
|
|
image?: SortOrder
|
|
emailVerified?: SortOrder
|
|
locale?: SortOrder
|
|
role?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type UserMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
email?: SortOrder
|
|
name?: SortOrder
|
|
image?: SortOrder
|
|
emailVerified?: SortOrder
|
|
locale?: SortOrder
|
|
role?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type UserMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
email?: SortOrder
|
|
name?: SortOrder
|
|
image?: SortOrder
|
|
emailVerified?: SortOrder
|
|
locale?: SortOrder
|
|
role?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type StringWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedStringFilter<$PrismaModel>
|
|
_max?: NestedStringFilter<$PrismaModel>
|
|
}
|
|
|
|
export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedStringNullableFilter<$PrismaModel>
|
|
_max?: NestedStringNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type 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 EnumRoleWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumRoleFilter<$PrismaModel>
|
|
_max?: NestedEnumRoleFilter<$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 IntNullableFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel> | null
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntNullableFilter<$PrismaModel> | number | null
|
|
}
|
|
|
|
export type UserScalarRelationFilter = {
|
|
is?: UserWhereInput
|
|
isNot?: UserWhereInput
|
|
}
|
|
|
|
export type AccountProviderProviderAccountIdCompoundUniqueInput = {
|
|
provider: string
|
|
providerAccountId: string
|
|
}
|
|
|
|
export type AccountCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
type?: SortOrder
|
|
provider?: SortOrder
|
|
providerAccountId?: SortOrder
|
|
refresh_token?: SortOrder
|
|
access_token?: SortOrder
|
|
expires_at?: SortOrder
|
|
token_type?: SortOrder
|
|
scope?: SortOrder
|
|
id_token?: SortOrder
|
|
session_state?: SortOrder
|
|
}
|
|
|
|
export type AccountAvgOrderByAggregateInput = {
|
|
expires_at?: SortOrder
|
|
}
|
|
|
|
export type AccountMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
type?: SortOrder
|
|
provider?: SortOrder
|
|
providerAccountId?: SortOrder
|
|
refresh_token?: SortOrder
|
|
access_token?: SortOrder
|
|
expires_at?: SortOrder
|
|
token_type?: SortOrder
|
|
scope?: SortOrder
|
|
id_token?: SortOrder
|
|
session_state?: SortOrder
|
|
}
|
|
|
|
export type AccountMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
type?: SortOrder
|
|
provider?: SortOrder
|
|
providerAccountId?: SortOrder
|
|
refresh_token?: SortOrder
|
|
access_token?: SortOrder
|
|
expires_at?: SortOrder
|
|
token_type?: SortOrder
|
|
scope?: SortOrder
|
|
id_token?: SortOrder
|
|
session_state?: SortOrder
|
|
}
|
|
|
|
export type AccountSumOrderByAggregateInput = {
|
|
expires_at?: SortOrder
|
|
}
|
|
|
|
export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel> | null
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedFloatNullableFilter<$PrismaModel>
|
|
_sum?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedIntNullableFilter<$PrismaModel>
|
|
_max?: NestedIntNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type SessionCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
sessionToken?: SortOrder
|
|
userId?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type SessionMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
sessionToken?: SortOrder
|
|
userId?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type SessionMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
sessionToken?: SortOrder
|
|
userId?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type VerificationTokenIdentifierTokenCompoundUniqueInput = {
|
|
identifier: string
|
|
token: string
|
|
}
|
|
|
|
export type VerificationTokenCountOrderByAggregateInput = {
|
|
identifier?: SortOrder
|
|
token?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type VerificationTokenMaxOrderByAggregateInput = {
|
|
identifier?: SortOrder
|
|
token?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type VerificationTokenMinOrderByAggregateInput = {
|
|
identifier?: SortOrder
|
|
token?: SortOrder
|
|
expires?: SortOrder
|
|
}
|
|
|
|
export type EnumCourseCategoryFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseCategory | EnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseCategoryFilter<$PrismaModel> | $Enums.CourseCategory
|
|
}
|
|
|
|
export type EnumCourseLevelFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseLevel | EnumCourseLevelFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseLevelFilter<$PrismaModel> | $Enums.CourseLevel
|
|
}
|
|
|
|
export type BoolFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolFilter<$PrismaModel> | boolean
|
|
}
|
|
|
|
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 ModuleListRelationFilter = {
|
|
every?: ModuleWhereInput
|
|
some?: ModuleWhereInput
|
|
none?: ModuleWhereInput
|
|
}
|
|
|
|
export type ModuleOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type CourseCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
slug?: SortOrder
|
|
category?: SortOrder
|
|
level?: SortOrder
|
|
thumbnailUrl?: SortOrder
|
|
published?: SortOrder
|
|
order?: SortOrder
|
|
createdAt?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
descFr?: SortOrder
|
|
descEn?: SortOrder
|
|
descEs?: SortOrder
|
|
}
|
|
|
|
export type CourseAvgOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
}
|
|
|
|
export type CourseMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
slug?: SortOrder
|
|
category?: SortOrder
|
|
level?: SortOrder
|
|
thumbnailUrl?: SortOrder
|
|
published?: SortOrder
|
|
order?: SortOrder
|
|
createdAt?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
descFr?: SortOrder
|
|
descEn?: SortOrder
|
|
descEs?: SortOrder
|
|
}
|
|
|
|
export type CourseMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
slug?: SortOrder
|
|
category?: SortOrder
|
|
level?: SortOrder
|
|
thumbnailUrl?: SortOrder
|
|
published?: SortOrder
|
|
order?: SortOrder
|
|
createdAt?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
descFr?: SortOrder
|
|
descEn?: SortOrder
|
|
descEs?: SortOrder
|
|
}
|
|
|
|
export type CourseSumOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
}
|
|
|
|
export type EnumCourseCategoryWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseCategory | EnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseCategoryWithAggregatesFilter<$PrismaModel> | $Enums.CourseCategory
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumCourseCategoryFilter<$PrismaModel>
|
|
_max?: NestedEnumCourseCategoryFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumCourseLevelWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseLevel | EnumCourseLevelFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseLevelWithAggregatesFilter<$PrismaModel> | $Enums.CourseLevel
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumCourseLevelFilter<$PrismaModel>
|
|
_max?: NestedEnumCourseLevelFilter<$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 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 CourseScalarRelationFilter = {
|
|
is?: CourseWhereInput
|
|
isNot?: CourseWhereInput
|
|
}
|
|
|
|
export type LessonListRelationFilter = {
|
|
every?: LessonWhereInput
|
|
some?: LessonWhereInput
|
|
none?: LessonWhereInput
|
|
}
|
|
|
|
export type QuizNullableScalarRelationFilter = {
|
|
is?: QuizWhereInput | null
|
|
isNot?: QuizWhereInput | null
|
|
}
|
|
|
|
export type LessonOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type ModuleCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
courseId?: SortOrder
|
|
order?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
}
|
|
|
|
export type ModuleAvgOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
}
|
|
|
|
export type ModuleMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
courseId?: SortOrder
|
|
order?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
}
|
|
|
|
export type ModuleMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
courseId?: SortOrder
|
|
order?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
}
|
|
|
|
export type ModuleSumOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
}
|
|
|
|
export type EnumLessonTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.LessonType | EnumLessonTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumLessonTypeFilter<$PrismaModel> | $Enums.LessonType
|
|
}
|
|
|
|
export type ModuleScalarRelationFilter = {
|
|
is?: ModuleWhereInput
|
|
isNot?: ModuleWhereInput
|
|
}
|
|
|
|
export type LessonCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
order?: SortOrder
|
|
type?: SortOrder
|
|
videoUrl?: SortOrder
|
|
duration?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
contentFr?: SortOrder
|
|
contentEn?: SortOrder
|
|
contentEs?: SortOrder
|
|
}
|
|
|
|
export type LessonAvgOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
duration?: SortOrder
|
|
}
|
|
|
|
export type LessonMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
order?: SortOrder
|
|
type?: SortOrder
|
|
videoUrl?: SortOrder
|
|
duration?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
contentFr?: SortOrder
|
|
contentEn?: SortOrder
|
|
contentEs?: SortOrder
|
|
}
|
|
|
|
export type LessonMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
order?: SortOrder
|
|
type?: SortOrder
|
|
videoUrl?: SortOrder
|
|
duration?: SortOrder
|
|
titleFr?: SortOrder
|
|
titleEn?: SortOrder
|
|
titleEs?: SortOrder
|
|
contentFr?: SortOrder
|
|
contentEn?: SortOrder
|
|
contentEs?: SortOrder
|
|
}
|
|
|
|
export type LessonSumOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
duration?: SortOrder
|
|
}
|
|
|
|
export type EnumLessonTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.LessonType | EnumLessonTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumLessonTypeWithAggregatesFilter<$PrismaModel> | $Enums.LessonType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumLessonTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumLessonTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type QuestionListRelationFilter = {
|
|
every?: QuestionWhereInput
|
|
some?: QuestionWhereInput
|
|
none?: QuestionWhereInput
|
|
}
|
|
|
|
export type QuestionOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type QuizCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
passMark?: SortOrder
|
|
}
|
|
|
|
export type QuizAvgOrderByAggregateInput = {
|
|
passMark?: SortOrder
|
|
}
|
|
|
|
export type QuizMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
passMark?: SortOrder
|
|
}
|
|
|
|
export type QuizMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
moduleId?: SortOrder
|
|
passMark?: SortOrder
|
|
}
|
|
|
|
export type QuizSumOrderByAggregateInput = {
|
|
passMark?: SortOrder
|
|
}
|
|
|
|
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 QuizScalarRelationFilter = {
|
|
is?: QuizWhereInput
|
|
isNot?: QuizWhereInput
|
|
}
|
|
|
|
export type QuestionCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
quizId?: SortOrder
|
|
order?: SortOrder
|
|
textFr?: SortOrder
|
|
textEn?: SortOrder
|
|
textEs?: SortOrder
|
|
optionsFr?: SortOrder
|
|
optionsEn?: SortOrder
|
|
optionsEs?: SortOrder
|
|
correctIndex?: SortOrder
|
|
}
|
|
|
|
export type QuestionAvgOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
correctIndex?: SortOrder
|
|
}
|
|
|
|
export type QuestionMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
quizId?: SortOrder
|
|
order?: SortOrder
|
|
textFr?: SortOrder
|
|
textEn?: SortOrder
|
|
textEs?: SortOrder
|
|
correctIndex?: SortOrder
|
|
}
|
|
|
|
export type QuestionMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
quizId?: SortOrder
|
|
order?: SortOrder
|
|
textFr?: SortOrder
|
|
textEn?: SortOrder
|
|
textEs?: SortOrder
|
|
correctIndex?: SortOrder
|
|
}
|
|
|
|
export type QuestionSumOrderByAggregateInput = {
|
|
order?: SortOrder
|
|
correctIndex?: SortOrder
|
|
}
|
|
|
|
export type EnrollmentUserIdCourseIdCompoundUniqueInput = {
|
|
userId: string
|
|
courseId: string
|
|
}
|
|
|
|
export type EnrollmentCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
enrolledAt?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type EnrollmentMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
enrolledAt?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type EnrollmentMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
enrolledAt?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type LessonScalarRelationFilter = {
|
|
is?: LessonWhereInput
|
|
isNot?: LessonWhereInput
|
|
}
|
|
|
|
export type LessonProgressUserIdLessonIdCompoundUniqueInput = {
|
|
userId: string
|
|
lessonId: string
|
|
}
|
|
|
|
export type LessonProgressCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
lessonId?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type LessonProgressMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
lessonId?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type LessonProgressMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
lessonId?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type IntNullableListFilter<$PrismaModel = never> = {
|
|
equals?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
has?: number | IntFieldRefInput<$PrismaModel> | null
|
|
hasEvery?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
hasSome?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
isEmpty?: boolean
|
|
}
|
|
|
|
export type QuizAttemptCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
quizId?: SortOrder
|
|
score?: SortOrder
|
|
passed?: SortOrder
|
|
answers?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type QuizAttemptAvgOrderByAggregateInput = {
|
|
score?: SortOrder
|
|
answers?: SortOrder
|
|
}
|
|
|
|
export type QuizAttemptMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
quizId?: SortOrder
|
|
score?: SortOrder
|
|
passed?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type QuizAttemptMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
quizId?: SortOrder
|
|
score?: SortOrder
|
|
passed?: SortOrder
|
|
completedAt?: SortOrder
|
|
}
|
|
|
|
export type QuizAttemptSumOrderByAggregateInput = {
|
|
score?: SortOrder
|
|
answers?: SortOrder
|
|
}
|
|
|
|
export type CertificateUserIdCourseIdCompoundUniqueInput = {
|
|
userId: string
|
|
courseId: string
|
|
}
|
|
|
|
export type CertificateCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
issuedAt?: SortOrder
|
|
pdfUrl?: SortOrder
|
|
isPaid?: SortOrder
|
|
}
|
|
|
|
export type CertificateMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
issuedAt?: SortOrder
|
|
pdfUrl?: SortOrder
|
|
isPaid?: SortOrder
|
|
}
|
|
|
|
export type CertificateMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
courseId?: SortOrder
|
|
issuedAt?: SortOrder
|
|
pdfUrl?: SortOrder
|
|
isPaid?: SortOrder
|
|
}
|
|
|
|
export type AccountCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
|
|
createMany?: AccountCreateManyUserInputEnvelope
|
|
connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
}
|
|
|
|
export type SessionCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
|
|
createMany?: SessionCreateManyUserInputEnvelope
|
|
connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnrollmentCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<EnrollmentCreateWithoutUserInput, EnrollmentUncheckedCreateWithoutUserInput> | EnrollmentCreateWithoutUserInput[] | EnrollmentUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutUserInput | EnrollmentCreateOrConnectWithoutUserInput[]
|
|
createMany?: EnrollmentCreateManyUserInputEnvelope
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
}
|
|
|
|
export type LessonProgressCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<LessonProgressCreateWithoutUserInput, LessonProgressUncheckedCreateWithoutUserInput> | LessonProgressCreateWithoutUserInput[] | LessonProgressUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutUserInput | LessonProgressCreateOrConnectWithoutUserInput[]
|
|
createMany?: LessonProgressCreateManyUserInputEnvelope
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuizAttemptCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutUserInput, QuizAttemptUncheckedCreateWithoutUserInput> | QuizAttemptCreateWithoutUserInput[] | QuizAttemptUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutUserInput | QuizAttemptCreateOrConnectWithoutUserInput[]
|
|
createMany?: QuizAttemptCreateManyUserInputEnvelope
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
}
|
|
|
|
export type CertificateCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<CertificateCreateWithoutUserInput, CertificateUncheckedCreateWithoutUserInput> | CertificateCreateWithoutUserInput[] | CertificateUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutUserInput | CertificateCreateOrConnectWithoutUserInput[]
|
|
createMany?: CertificateCreateManyUserInputEnvelope
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
}
|
|
|
|
export type AccountUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
|
|
createMany?: AccountCreateManyUserInputEnvelope
|
|
connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
}
|
|
|
|
export type SessionUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
|
|
createMany?: SessionCreateManyUserInputEnvelope
|
|
connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnrollmentUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<EnrollmentCreateWithoutUserInput, EnrollmentUncheckedCreateWithoutUserInput> | EnrollmentCreateWithoutUserInput[] | EnrollmentUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutUserInput | EnrollmentCreateOrConnectWithoutUserInput[]
|
|
createMany?: EnrollmentCreateManyUserInputEnvelope
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
}
|
|
|
|
export type LessonProgressUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<LessonProgressCreateWithoutUserInput, LessonProgressUncheckedCreateWithoutUserInput> | LessonProgressCreateWithoutUserInput[] | LessonProgressUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutUserInput | LessonProgressCreateOrConnectWithoutUserInput[]
|
|
createMany?: LessonProgressCreateManyUserInputEnvelope
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuizAttemptUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutUserInput, QuizAttemptUncheckedCreateWithoutUserInput> | QuizAttemptCreateWithoutUserInput[] | QuizAttemptUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutUserInput | QuizAttemptCreateOrConnectWithoutUserInput[]
|
|
createMany?: QuizAttemptCreateManyUserInputEnvelope
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
}
|
|
|
|
export type CertificateUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<CertificateCreateWithoutUserInput, CertificateUncheckedCreateWithoutUserInput> | CertificateCreateWithoutUserInput[] | CertificateUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutUserInput | CertificateCreateOrConnectWithoutUserInput[]
|
|
createMany?: CertificateCreateManyUserInputEnvelope
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
}
|
|
|
|
export type StringFieldUpdateOperationsInput = {
|
|
set?: string
|
|
}
|
|
|
|
export type NullableStringFieldUpdateOperationsInput = {
|
|
set?: string | null
|
|
}
|
|
|
|
export type NullableDateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string | null
|
|
}
|
|
|
|
export type EnumRoleFieldUpdateOperationsInput = {
|
|
set?: $Enums.Role
|
|
}
|
|
|
|
export type DateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string
|
|
}
|
|
|
|
export type AccountUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
|
|
upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: AccountCreateManyUserInputEnvelope
|
|
set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
|
|
}
|
|
|
|
export type SessionUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
|
|
upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: SessionCreateManyUserInputEnvelope
|
|
set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
|
|
}
|
|
|
|
export type EnrollmentUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<EnrollmentCreateWithoutUserInput, EnrollmentUncheckedCreateWithoutUserInput> | EnrollmentCreateWithoutUserInput[] | EnrollmentUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutUserInput | EnrollmentCreateOrConnectWithoutUserInput[]
|
|
upsert?: EnrollmentUpsertWithWhereUniqueWithoutUserInput | EnrollmentUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: EnrollmentCreateManyUserInputEnvelope
|
|
set?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
disconnect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
delete?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
update?: EnrollmentUpdateWithWhereUniqueWithoutUserInput | EnrollmentUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: EnrollmentUpdateManyWithWhereWithoutUserInput | EnrollmentUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: EnrollmentScalarWhereInput | EnrollmentScalarWhereInput[]
|
|
}
|
|
|
|
export type LessonProgressUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<LessonProgressCreateWithoutUserInput, LessonProgressUncheckedCreateWithoutUserInput> | LessonProgressCreateWithoutUserInput[] | LessonProgressUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutUserInput | LessonProgressCreateOrConnectWithoutUserInput[]
|
|
upsert?: LessonProgressUpsertWithWhereUniqueWithoutUserInput | LessonProgressUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: LessonProgressCreateManyUserInputEnvelope
|
|
set?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
disconnect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
delete?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
update?: LessonProgressUpdateWithWhereUniqueWithoutUserInput | LessonProgressUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: LessonProgressUpdateManyWithWhereWithoutUserInput | LessonProgressUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: LessonProgressScalarWhereInput | LessonProgressScalarWhereInput[]
|
|
}
|
|
|
|
export type QuizAttemptUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutUserInput, QuizAttemptUncheckedCreateWithoutUserInput> | QuizAttemptCreateWithoutUserInput[] | QuizAttemptUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutUserInput | QuizAttemptCreateOrConnectWithoutUserInput[]
|
|
upsert?: QuizAttemptUpsertWithWhereUniqueWithoutUserInput | QuizAttemptUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: QuizAttemptCreateManyUserInputEnvelope
|
|
set?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
disconnect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
delete?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
update?: QuizAttemptUpdateWithWhereUniqueWithoutUserInput | QuizAttemptUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: QuizAttemptUpdateManyWithWhereWithoutUserInput | QuizAttemptUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: QuizAttemptScalarWhereInput | QuizAttemptScalarWhereInput[]
|
|
}
|
|
|
|
export type CertificateUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<CertificateCreateWithoutUserInput, CertificateUncheckedCreateWithoutUserInput> | CertificateCreateWithoutUserInput[] | CertificateUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutUserInput | CertificateCreateOrConnectWithoutUserInput[]
|
|
upsert?: CertificateUpsertWithWhereUniqueWithoutUserInput | CertificateUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: CertificateCreateManyUserInputEnvelope
|
|
set?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
disconnect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
delete?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
update?: CertificateUpdateWithWhereUniqueWithoutUserInput | CertificateUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: CertificateUpdateManyWithWhereWithoutUserInput | CertificateUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: CertificateScalarWhereInput | CertificateScalarWhereInput[]
|
|
}
|
|
|
|
export type AccountUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
|
|
upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: AccountCreateManyUserInputEnvelope
|
|
set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
|
|
update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
|
|
}
|
|
|
|
export type SessionUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
|
|
upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: SessionCreateManyUserInputEnvelope
|
|
set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
|
|
update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<EnrollmentCreateWithoutUserInput, EnrollmentUncheckedCreateWithoutUserInput> | EnrollmentCreateWithoutUserInput[] | EnrollmentUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutUserInput | EnrollmentCreateOrConnectWithoutUserInput[]
|
|
upsert?: EnrollmentUpsertWithWhereUniqueWithoutUserInput | EnrollmentUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: EnrollmentCreateManyUserInputEnvelope
|
|
set?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
disconnect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
delete?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
update?: EnrollmentUpdateWithWhereUniqueWithoutUserInput | EnrollmentUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: EnrollmentUpdateManyWithWhereWithoutUserInput | EnrollmentUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: EnrollmentScalarWhereInput | EnrollmentScalarWhereInput[]
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<LessonProgressCreateWithoutUserInput, LessonProgressUncheckedCreateWithoutUserInput> | LessonProgressCreateWithoutUserInput[] | LessonProgressUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutUserInput | LessonProgressCreateOrConnectWithoutUserInput[]
|
|
upsert?: LessonProgressUpsertWithWhereUniqueWithoutUserInput | LessonProgressUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: LessonProgressCreateManyUserInputEnvelope
|
|
set?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
disconnect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
delete?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
update?: LessonProgressUpdateWithWhereUniqueWithoutUserInput | LessonProgressUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: LessonProgressUpdateManyWithWhereWithoutUserInput | LessonProgressUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: LessonProgressScalarWhereInput | LessonProgressScalarWhereInput[]
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutUserInput, QuizAttemptUncheckedCreateWithoutUserInput> | QuizAttemptCreateWithoutUserInput[] | QuizAttemptUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutUserInput | QuizAttemptCreateOrConnectWithoutUserInput[]
|
|
upsert?: QuizAttemptUpsertWithWhereUniqueWithoutUserInput | QuizAttemptUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: QuizAttemptCreateManyUserInputEnvelope
|
|
set?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
disconnect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
delete?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
update?: QuizAttemptUpdateWithWhereUniqueWithoutUserInput | QuizAttemptUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: QuizAttemptUpdateManyWithWhereWithoutUserInput | QuizAttemptUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: QuizAttemptScalarWhereInput | QuizAttemptScalarWhereInput[]
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<CertificateCreateWithoutUserInput, CertificateUncheckedCreateWithoutUserInput> | CertificateCreateWithoutUserInput[] | CertificateUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutUserInput | CertificateCreateOrConnectWithoutUserInput[]
|
|
upsert?: CertificateUpsertWithWhereUniqueWithoutUserInput | CertificateUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: CertificateCreateManyUserInputEnvelope
|
|
set?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
disconnect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
delete?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
update?: CertificateUpdateWithWhereUniqueWithoutUserInput | CertificateUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: CertificateUpdateManyWithWhereWithoutUserInput | CertificateUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: CertificateScalarWhereInput | CertificateScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutAccountsInput = {
|
|
create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type NullableIntFieldUpdateOperationsInput = {
|
|
set?: number | null
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutAccountsNestedInput = {
|
|
create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
|
|
upsert?: UserUpsertWithoutAccountsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccountsInput, UserUpdateWithoutAccountsInput>, UserUncheckedUpdateWithoutAccountsInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutSessionsInput = {
|
|
create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutSessionsNestedInput = {
|
|
create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
|
|
upsert?: UserUpsertWithoutSessionsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSessionsInput, UserUpdateWithoutSessionsInput>, UserUncheckedUpdateWithoutSessionsInput>
|
|
}
|
|
|
|
export type ModuleCreateNestedManyWithoutCourseInput = {
|
|
create?: XOR<ModuleCreateWithoutCourseInput, ModuleUncheckedCreateWithoutCourseInput> | ModuleCreateWithoutCourseInput[] | ModuleUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutCourseInput | ModuleCreateOrConnectWithoutCourseInput[]
|
|
createMany?: ModuleCreateManyCourseInputEnvelope
|
|
connect?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnrollmentCreateNestedManyWithoutCourseInput = {
|
|
create?: XOR<EnrollmentCreateWithoutCourseInput, EnrollmentUncheckedCreateWithoutCourseInput> | EnrollmentCreateWithoutCourseInput[] | EnrollmentUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutCourseInput | EnrollmentCreateOrConnectWithoutCourseInput[]
|
|
createMany?: EnrollmentCreateManyCourseInputEnvelope
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
}
|
|
|
|
export type CertificateCreateNestedManyWithoutCourseInput = {
|
|
create?: XOR<CertificateCreateWithoutCourseInput, CertificateUncheckedCreateWithoutCourseInput> | CertificateCreateWithoutCourseInput[] | CertificateUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutCourseInput | CertificateCreateOrConnectWithoutCourseInput[]
|
|
createMany?: CertificateCreateManyCourseInputEnvelope
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
}
|
|
|
|
export type ModuleUncheckedCreateNestedManyWithoutCourseInput = {
|
|
create?: XOR<ModuleCreateWithoutCourseInput, ModuleUncheckedCreateWithoutCourseInput> | ModuleCreateWithoutCourseInput[] | ModuleUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutCourseInput | ModuleCreateOrConnectWithoutCourseInput[]
|
|
createMany?: ModuleCreateManyCourseInputEnvelope
|
|
connect?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnrollmentUncheckedCreateNestedManyWithoutCourseInput = {
|
|
create?: XOR<EnrollmentCreateWithoutCourseInput, EnrollmentUncheckedCreateWithoutCourseInput> | EnrollmentCreateWithoutCourseInput[] | EnrollmentUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutCourseInput | EnrollmentCreateOrConnectWithoutCourseInput[]
|
|
createMany?: EnrollmentCreateManyCourseInputEnvelope
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
}
|
|
|
|
export type CertificateUncheckedCreateNestedManyWithoutCourseInput = {
|
|
create?: XOR<CertificateCreateWithoutCourseInput, CertificateUncheckedCreateWithoutCourseInput> | CertificateCreateWithoutCourseInput[] | CertificateUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutCourseInput | CertificateCreateOrConnectWithoutCourseInput[]
|
|
createMany?: CertificateCreateManyCourseInputEnvelope
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnumCourseCategoryFieldUpdateOperationsInput = {
|
|
set?: $Enums.CourseCategory
|
|
}
|
|
|
|
export type EnumCourseLevelFieldUpdateOperationsInput = {
|
|
set?: $Enums.CourseLevel
|
|
}
|
|
|
|
export type BoolFieldUpdateOperationsInput = {
|
|
set?: boolean
|
|
}
|
|
|
|
export type IntFieldUpdateOperationsInput = {
|
|
set?: number
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type ModuleUpdateManyWithoutCourseNestedInput = {
|
|
create?: XOR<ModuleCreateWithoutCourseInput, ModuleUncheckedCreateWithoutCourseInput> | ModuleCreateWithoutCourseInput[] | ModuleUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutCourseInput | ModuleCreateOrConnectWithoutCourseInput[]
|
|
upsert?: ModuleUpsertWithWhereUniqueWithoutCourseInput | ModuleUpsertWithWhereUniqueWithoutCourseInput[]
|
|
createMany?: ModuleCreateManyCourseInputEnvelope
|
|
set?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
disconnect?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
delete?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
connect?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
update?: ModuleUpdateWithWhereUniqueWithoutCourseInput | ModuleUpdateWithWhereUniqueWithoutCourseInput[]
|
|
updateMany?: ModuleUpdateManyWithWhereWithoutCourseInput | ModuleUpdateManyWithWhereWithoutCourseInput[]
|
|
deleteMany?: ModuleScalarWhereInput | ModuleScalarWhereInput[]
|
|
}
|
|
|
|
export type EnrollmentUpdateManyWithoutCourseNestedInput = {
|
|
create?: XOR<EnrollmentCreateWithoutCourseInput, EnrollmentUncheckedCreateWithoutCourseInput> | EnrollmentCreateWithoutCourseInput[] | EnrollmentUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutCourseInput | EnrollmentCreateOrConnectWithoutCourseInput[]
|
|
upsert?: EnrollmentUpsertWithWhereUniqueWithoutCourseInput | EnrollmentUpsertWithWhereUniqueWithoutCourseInput[]
|
|
createMany?: EnrollmentCreateManyCourseInputEnvelope
|
|
set?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
disconnect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
delete?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
update?: EnrollmentUpdateWithWhereUniqueWithoutCourseInput | EnrollmentUpdateWithWhereUniqueWithoutCourseInput[]
|
|
updateMany?: EnrollmentUpdateManyWithWhereWithoutCourseInput | EnrollmentUpdateManyWithWhereWithoutCourseInput[]
|
|
deleteMany?: EnrollmentScalarWhereInput | EnrollmentScalarWhereInput[]
|
|
}
|
|
|
|
export type CertificateUpdateManyWithoutCourseNestedInput = {
|
|
create?: XOR<CertificateCreateWithoutCourseInput, CertificateUncheckedCreateWithoutCourseInput> | CertificateCreateWithoutCourseInput[] | CertificateUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutCourseInput | CertificateCreateOrConnectWithoutCourseInput[]
|
|
upsert?: CertificateUpsertWithWhereUniqueWithoutCourseInput | CertificateUpsertWithWhereUniqueWithoutCourseInput[]
|
|
createMany?: CertificateCreateManyCourseInputEnvelope
|
|
set?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
disconnect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
delete?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
update?: CertificateUpdateWithWhereUniqueWithoutCourseInput | CertificateUpdateWithWhereUniqueWithoutCourseInput[]
|
|
updateMany?: CertificateUpdateManyWithWhereWithoutCourseInput | CertificateUpdateManyWithWhereWithoutCourseInput[]
|
|
deleteMany?: CertificateScalarWhereInput | CertificateScalarWhereInput[]
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateManyWithoutCourseNestedInput = {
|
|
create?: XOR<ModuleCreateWithoutCourseInput, ModuleUncheckedCreateWithoutCourseInput> | ModuleCreateWithoutCourseInput[] | ModuleUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutCourseInput | ModuleCreateOrConnectWithoutCourseInput[]
|
|
upsert?: ModuleUpsertWithWhereUniqueWithoutCourseInput | ModuleUpsertWithWhereUniqueWithoutCourseInput[]
|
|
createMany?: ModuleCreateManyCourseInputEnvelope
|
|
set?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
disconnect?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
delete?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
connect?: ModuleWhereUniqueInput | ModuleWhereUniqueInput[]
|
|
update?: ModuleUpdateWithWhereUniqueWithoutCourseInput | ModuleUpdateWithWhereUniqueWithoutCourseInput[]
|
|
updateMany?: ModuleUpdateManyWithWhereWithoutCourseInput | ModuleUpdateManyWithWhereWithoutCourseInput[]
|
|
deleteMany?: ModuleScalarWhereInput | ModuleScalarWhereInput[]
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateManyWithoutCourseNestedInput = {
|
|
create?: XOR<EnrollmentCreateWithoutCourseInput, EnrollmentUncheckedCreateWithoutCourseInput> | EnrollmentCreateWithoutCourseInput[] | EnrollmentUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: EnrollmentCreateOrConnectWithoutCourseInput | EnrollmentCreateOrConnectWithoutCourseInput[]
|
|
upsert?: EnrollmentUpsertWithWhereUniqueWithoutCourseInput | EnrollmentUpsertWithWhereUniqueWithoutCourseInput[]
|
|
createMany?: EnrollmentCreateManyCourseInputEnvelope
|
|
set?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
disconnect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
delete?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
connect?: EnrollmentWhereUniqueInput | EnrollmentWhereUniqueInput[]
|
|
update?: EnrollmentUpdateWithWhereUniqueWithoutCourseInput | EnrollmentUpdateWithWhereUniqueWithoutCourseInput[]
|
|
updateMany?: EnrollmentUpdateManyWithWhereWithoutCourseInput | EnrollmentUpdateManyWithWhereWithoutCourseInput[]
|
|
deleteMany?: EnrollmentScalarWhereInput | EnrollmentScalarWhereInput[]
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateManyWithoutCourseNestedInput = {
|
|
create?: XOR<CertificateCreateWithoutCourseInput, CertificateUncheckedCreateWithoutCourseInput> | CertificateCreateWithoutCourseInput[] | CertificateUncheckedCreateWithoutCourseInput[]
|
|
connectOrCreate?: CertificateCreateOrConnectWithoutCourseInput | CertificateCreateOrConnectWithoutCourseInput[]
|
|
upsert?: CertificateUpsertWithWhereUniqueWithoutCourseInput | CertificateUpsertWithWhereUniqueWithoutCourseInput[]
|
|
createMany?: CertificateCreateManyCourseInputEnvelope
|
|
set?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
disconnect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
delete?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
connect?: CertificateWhereUniqueInput | CertificateWhereUniqueInput[]
|
|
update?: CertificateUpdateWithWhereUniqueWithoutCourseInput | CertificateUpdateWithWhereUniqueWithoutCourseInput[]
|
|
updateMany?: CertificateUpdateManyWithWhereWithoutCourseInput | CertificateUpdateManyWithWhereWithoutCourseInput[]
|
|
deleteMany?: CertificateScalarWhereInput | CertificateScalarWhereInput[]
|
|
}
|
|
|
|
export type CourseCreateNestedOneWithoutModulesInput = {
|
|
create?: XOR<CourseCreateWithoutModulesInput, CourseUncheckedCreateWithoutModulesInput>
|
|
connectOrCreate?: CourseCreateOrConnectWithoutModulesInput
|
|
connect?: CourseWhereUniqueInput
|
|
}
|
|
|
|
export type LessonCreateNestedManyWithoutModuleInput = {
|
|
create?: XOR<LessonCreateWithoutModuleInput, LessonUncheckedCreateWithoutModuleInput> | LessonCreateWithoutModuleInput[] | LessonUncheckedCreateWithoutModuleInput[]
|
|
connectOrCreate?: LessonCreateOrConnectWithoutModuleInput | LessonCreateOrConnectWithoutModuleInput[]
|
|
createMany?: LessonCreateManyModuleInputEnvelope
|
|
connect?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuizCreateNestedOneWithoutModuleInput = {
|
|
create?: XOR<QuizCreateWithoutModuleInput, QuizUncheckedCreateWithoutModuleInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutModuleInput
|
|
connect?: QuizWhereUniqueInput
|
|
}
|
|
|
|
export type LessonUncheckedCreateNestedManyWithoutModuleInput = {
|
|
create?: XOR<LessonCreateWithoutModuleInput, LessonUncheckedCreateWithoutModuleInput> | LessonCreateWithoutModuleInput[] | LessonUncheckedCreateWithoutModuleInput[]
|
|
connectOrCreate?: LessonCreateOrConnectWithoutModuleInput | LessonCreateOrConnectWithoutModuleInput[]
|
|
createMany?: LessonCreateManyModuleInputEnvelope
|
|
connect?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuizUncheckedCreateNestedOneWithoutModuleInput = {
|
|
create?: XOR<QuizCreateWithoutModuleInput, QuizUncheckedCreateWithoutModuleInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutModuleInput
|
|
connect?: QuizWhereUniqueInput
|
|
}
|
|
|
|
export type CourseUpdateOneRequiredWithoutModulesNestedInput = {
|
|
create?: XOR<CourseCreateWithoutModulesInput, CourseUncheckedCreateWithoutModulesInput>
|
|
connectOrCreate?: CourseCreateOrConnectWithoutModulesInput
|
|
upsert?: CourseUpsertWithoutModulesInput
|
|
connect?: CourseWhereUniqueInput
|
|
update?: XOR<XOR<CourseUpdateToOneWithWhereWithoutModulesInput, CourseUpdateWithoutModulesInput>, CourseUncheckedUpdateWithoutModulesInput>
|
|
}
|
|
|
|
export type LessonUpdateManyWithoutModuleNestedInput = {
|
|
create?: XOR<LessonCreateWithoutModuleInput, LessonUncheckedCreateWithoutModuleInput> | LessonCreateWithoutModuleInput[] | LessonUncheckedCreateWithoutModuleInput[]
|
|
connectOrCreate?: LessonCreateOrConnectWithoutModuleInput | LessonCreateOrConnectWithoutModuleInput[]
|
|
upsert?: LessonUpsertWithWhereUniqueWithoutModuleInput | LessonUpsertWithWhereUniqueWithoutModuleInput[]
|
|
createMany?: LessonCreateManyModuleInputEnvelope
|
|
set?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
disconnect?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
delete?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
connect?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
update?: LessonUpdateWithWhereUniqueWithoutModuleInput | LessonUpdateWithWhereUniqueWithoutModuleInput[]
|
|
updateMany?: LessonUpdateManyWithWhereWithoutModuleInput | LessonUpdateManyWithWhereWithoutModuleInput[]
|
|
deleteMany?: LessonScalarWhereInput | LessonScalarWhereInput[]
|
|
}
|
|
|
|
export type QuizUpdateOneWithoutModuleNestedInput = {
|
|
create?: XOR<QuizCreateWithoutModuleInput, QuizUncheckedCreateWithoutModuleInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutModuleInput
|
|
upsert?: QuizUpsertWithoutModuleInput
|
|
disconnect?: QuizWhereInput | boolean
|
|
delete?: QuizWhereInput | boolean
|
|
connect?: QuizWhereUniqueInput
|
|
update?: XOR<XOR<QuizUpdateToOneWithWhereWithoutModuleInput, QuizUpdateWithoutModuleInput>, QuizUncheckedUpdateWithoutModuleInput>
|
|
}
|
|
|
|
export type LessonUncheckedUpdateManyWithoutModuleNestedInput = {
|
|
create?: XOR<LessonCreateWithoutModuleInput, LessonUncheckedCreateWithoutModuleInput> | LessonCreateWithoutModuleInput[] | LessonUncheckedCreateWithoutModuleInput[]
|
|
connectOrCreate?: LessonCreateOrConnectWithoutModuleInput | LessonCreateOrConnectWithoutModuleInput[]
|
|
upsert?: LessonUpsertWithWhereUniqueWithoutModuleInput | LessonUpsertWithWhereUniqueWithoutModuleInput[]
|
|
createMany?: LessonCreateManyModuleInputEnvelope
|
|
set?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
disconnect?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
delete?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
connect?: LessonWhereUniqueInput | LessonWhereUniqueInput[]
|
|
update?: LessonUpdateWithWhereUniqueWithoutModuleInput | LessonUpdateWithWhereUniqueWithoutModuleInput[]
|
|
updateMany?: LessonUpdateManyWithWhereWithoutModuleInput | LessonUpdateManyWithWhereWithoutModuleInput[]
|
|
deleteMany?: LessonScalarWhereInput | LessonScalarWhereInput[]
|
|
}
|
|
|
|
export type QuizUncheckedUpdateOneWithoutModuleNestedInput = {
|
|
create?: XOR<QuizCreateWithoutModuleInput, QuizUncheckedCreateWithoutModuleInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutModuleInput
|
|
upsert?: QuizUpsertWithoutModuleInput
|
|
disconnect?: QuizWhereInput | boolean
|
|
delete?: QuizWhereInput | boolean
|
|
connect?: QuizWhereUniqueInput
|
|
update?: XOR<XOR<QuizUpdateToOneWithWhereWithoutModuleInput, QuizUpdateWithoutModuleInput>, QuizUncheckedUpdateWithoutModuleInput>
|
|
}
|
|
|
|
export type ModuleCreateNestedOneWithoutLessonsInput = {
|
|
create?: XOR<ModuleCreateWithoutLessonsInput, ModuleUncheckedCreateWithoutLessonsInput>
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutLessonsInput
|
|
connect?: ModuleWhereUniqueInput
|
|
}
|
|
|
|
export type LessonProgressCreateNestedManyWithoutLessonInput = {
|
|
create?: XOR<LessonProgressCreateWithoutLessonInput, LessonProgressUncheckedCreateWithoutLessonInput> | LessonProgressCreateWithoutLessonInput[] | LessonProgressUncheckedCreateWithoutLessonInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutLessonInput | LessonProgressCreateOrConnectWithoutLessonInput[]
|
|
createMany?: LessonProgressCreateManyLessonInputEnvelope
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
}
|
|
|
|
export type LessonProgressUncheckedCreateNestedManyWithoutLessonInput = {
|
|
create?: XOR<LessonProgressCreateWithoutLessonInput, LessonProgressUncheckedCreateWithoutLessonInput> | LessonProgressCreateWithoutLessonInput[] | LessonProgressUncheckedCreateWithoutLessonInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutLessonInput | LessonProgressCreateOrConnectWithoutLessonInput[]
|
|
createMany?: LessonProgressCreateManyLessonInputEnvelope
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnumLessonTypeFieldUpdateOperationsInput = {
|
|
set?: $Enums.LessonType
|
|
}
|
|
|
|
export type ModuleUpdateOneRequiredWithoutLessonsNestedInput = {
|
|
create?: XOR<ModuleCreateWithoutLessonsInput, ModuleUncheckedCreateWithoutLessonsInput>
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutLessonsInput
|
|
upsert?: ModuleUpsertWithoutLessonsInput
|
|
connect?: ModuleWhereUniqueInput
|
|
update?: XOR<XOR<ModuleUpdateToOneWithWhereWithoutLessonsInput, ModuleUpdateWithoutLessonsInput>, ModuleUncheckedUpdateWithoutLessonsInput>
|
|
}
|
|
|
|
export type LessonProgressUpdateManyWithoutLessonNestedInput = {
|
|
create?: XOR<LessonProgressCreateWithoutLessonInput, LessonProgressUncheckedCreateWithoutLessonInput> | LessonProgressCreateWithoutLessonInput[] | LessonProgressUncheckedCreateWithoutLessonInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutLessonInput | LessonProgressCreateOrConnectWithoutLessonInput[]
|
|
upsert?: LessonProgressUpsertWithWhereUniqueWithoutLessonInput | LessonProgressUpsertWithWhereUniqueWithoutLessonInput[]
|
|
createMany?: LessonProgressCreateManyLessonInputEnvelope
|
|
set?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
disconnect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
delete?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
update?: LessonProgressUpdateWithWhereUniqueWithoutLessonInput | LessonProgressUpdateWithWhereUniqueWithoutLessonInput[]
|
|
updateMany?: LessonProgressUpdateManyWithWhereWithoutLessonInput | LessonProgressUpdateManyWithWhereWithoutLessonInput[]
|
|
deleteMany?: LessonProgressScalarWhereInput | LessonProgressScalarWhereInput[]
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateManyWithoutLessonNestedInput = {
|
|
create?: XOR<LessonProgressCreateWithoutLessonInput, LessonProgressUncheckedCreateWithoutLessonInput> | LessonProgressCreateWithoutLessonInput[] | LessonProgressUncheckedCreateWithoutLessonInput[]
|
|
connectOrCreate?: LessonProgressCreateOrConnectWithoutLessonInput | LessonProgressCreateOrConnectWithoutLessonInput[]
|
|
upsert?: LessonProgressUpsertWithWhereUniqueWithoutLessonInput | LessonProgressUpsertWithWhereUniqueWithoutLessonInput[]
|
|
createMany?: LessonProgressCreateManyLessonInputEnvelope
|
|
set?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
disconnect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
delete?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
connect?: LessonProgressWhereUniqueInput | LessonProgressWhereUniqueInput[]
|
|
update?: LessonProgressUpdateWithWhereUniqueWithoutLessonInput | LessonProgressUpdateWithWhereUniqueWithoutLessonInput[]
|
|
updateMany?: LessonProgressUpdateManyWithWhereWithoutLessonInput | LessonProgressUpdateManyWithWhereWithoutLessonInput[]
|
|
deleteMany?: LessonProgressScalarWhereInput | LessonProgressScalarWhereInput[]
|
|
}
|
|
|
|
export type ModuleCreateNestedOneWithoutQuizInput = {
|
|
create?: XOR<ModuleCreateWithoutQuizInput, ModuleUncheckedCreateWithoutQuizInput>
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutQuizInput
|
|
connect?: ModuleWhereUniqueInput
|
|
}
|
|
|
|
export type QuestionCreateNestedManyWithoutQuizInput = {
|
|
create?: XOR<QuestionCreateWithoutQuizInput, QuestionUncheckedCreateWithoutQuizInput> | QuestionCreateWithoutQuizInput[] | QuestionUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuestionCreateOrConnectWithoutQuizInput | QuestionCreateOrConnectWithoutQuizInput[]
|
|
createMany?: QuestionCreateManyQuizInputEnvelope
|
|
connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuizAttemptCreateNestedManyWithoutQuizInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutQuizInput, QuizAttemptUncheckedCreateWithoutQuizInput> | QuizAttemptCreateWithoutQuizInput[] | QuizAttemptUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutQuizInput | QuizAttemptCreateOrConnectWithoutQuizInput[]
|
|
createMany?: QuizAttemptCreateManyQuizInputEnvelope
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuestionUncheckedCreateNestedManyWithoutQuizInput = {
|
|
create?: XOR<QuestionCreateWithoutQuizInput, QuestionUncheckedCreateWithoutQuizInput> | QuestionCreateWithoutQuizInput[] | QuestionUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuestionCreateOrConnectWithoutQuizInput | QuestionCreateOrConnectWithoutQuizInput[]
|
|
createMany?: QuestionCreateManyQuizInputEnvelope
|
|
connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
}
|
|
|
|
export type QuizAttemptUncheckedCreateNestedManyWithoutQuizInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutQuizInput, QuizAttemptUncheckedCreateWithoutQuizInput> | QuizAttemptCreateWithoutQuizInput[] | QuizAttemptUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutQuizInput | QuizAttemptCreateOrConnectWithoutQuizInput[]
|
|
createMany?: QuizAttemptCreateManyQuizInputEnvelope
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
}
|
|
|
|
export type ModuleUpdateOneRequiredWithoutQuizNestedInput = {
|
|
create?: XOR<ModuleCreateWithoutQuizInput, ModuleUncheckedCreateWithoutQuizInput>
|
|
connectOrCreate?: ModuleCreateOrConnectWithoutQuizInput
|
|
upsert?: ModuleUpsertWithoutQuizInput
|
|
connect?: ModuleWhereUniqueInput
|
|
update?: XOR<XOR<ModuleUpdateToOneWithWhereWithoutQuizInput, ModuleUpdateWithoutQuizInput>, ModuleUncheckedUpdateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuestionUpdateManyWithoutQuizNestedInput = {
|
|
create?: XOR<QuestionCreateWithoutQuizInput, QuestionUncheckedCreateWithoutQuizInput> | QuestionCreateWithoutQuizInput[] | QuestionUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuestionCreateOrConnectWithoutQuizInput | QuestionCreateOrConnectWithoutQuizInput[]
|
|
upsert?: QuestionUpsertWithWhereUniqueWithoutQuizInput | QuestionUpsertWithWhereUniqueWithoutQuizInput[]
|
|
createMany?: QuestionCreateManyQuizInputEnvelope
|
|
set?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
disconnect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
delete?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
update?: QuestionUpdateWithWhereUniqueWithoutQuizInput | QuestionUpdateWithWhereUniqueWithoutQuizInput[]
|
|
updateMany?: QuestionUpdateManyWithWhereWithoutQuizInput | QuestionUpdateManyWithWhereWithoutQuizInput[]
|
|
deleteMany?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
|
|
}
|
|
|
|
export type QuizAttemptUpdateManyWithoutQuizNestedInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutQuizInput, QuizAttemptUncheckedCreateWithoutQuizInput> | QuizAttemptCreateWithoutQuizInput[] | QuizAttemptUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutQuizInput | QuizAttemptCreateOrConnectWithoutQuizInput[]
|
|
upsert?: QuizAttemptUpsertWithWhereUniqueWithoutQuizInput | QuizAttemptUpsertWithWhereUniqueWithoutQuizInput[]
|
|
createMany?: QuizAttemptCreateManyQuizInputEnvelope
|
|
set?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
disconnect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
delete?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
update?: QuizAttemptUpdateWithWhereUniqueWithoutQuizInput | QuizAttemptUpdateWithWhereUniqueWithoutQuizInput[]
|
|
updateMany?: QuizAttemptUpdateManyWithWhereWithoutQuizInput | QuizAttemptUpdateManyWithWhereWithoutQuizInput[]
|
|
deleteMany?: QuizAttemptScalarWhereInput | QuizAttemptScalarWhereInput[]
|
|
}
|
|
|
|
export type QuestionUncheckedUpdateManyWithoutQuizNestedInput = {
|
|
create?: XOR<QuestionCreateWithoutQuizInput, QuestionUncheckedCreateWithoutQuizInput> | QuestionCreateWithoutQuizInput[] | QuestionUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuestionCreateOrConnectWithoutQuizInput | QuestionCreateOrConnectWithoutQuizInput[]
|
|
upsert?: QuestionUpsertWithWhereUniqueWithoutQuizInput | QuestionUpsertWithWhereUniqueWithoutQuizInput[]
|
|
createMany?: QuestionCreateManyQuizInputEnvelope
|
|
set?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
disconnect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
delete?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
connect?: QuestionWhereUniqueInput | QuestionWhereUniqueInput[]
|
|
update?: QuestionUpdateWithWhereUniqueWithoutQuizInput | QuestionUpdateWithWhereUniqueWithoutQuizInput[]
|
|
updateMany?: QuestionUpdateManyWithWhereWithoutQuizInput | QuestionUpdateManyWithWhereWithoutQuizInput[]
|
|
deleteMany?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateManyWithoutQuizNestedInput = {
|
|
create?: XOR<QuizAttemptCreateWithoutQuizInput, QuizAttemptUncheckedCreateWithoutQuizInput> | QuizAttemptCreateWithoutQuizInput[] | QuizAttemptUncheckedCreateWithoutQuizInput[]
|
|
connectOrCreate?: QuizAttemptCreateOrConnectWithoutQuizInput | QuizAttemptCreateOrConnectWithoutQuizInput[]
|
|
upsert?: QuizAttemptUpsertWithWhereUniqueWithoutQuizInput | QuizAttemptUpsertWithWhereUniqueWithoutQuizInput[]
|
|
createMany?: QuizAttemptCreateManyQuizInputEnvelope
|
|
set?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
disconnect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
delete?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
connect?: QuizAttemptWhereUniqueInput | QuizAttemptWhereUniqueInput[]
|
|
update?: QuizAttemptUpdateWithWhereUniqueWithoutQuizInput | QuizAttemptUpdateWithWhereUniqueWithoutQuizInput[]
|
|
updateMany?: QuizAttemptUpdateManyWithWhereWithoutQuizInput | QuizAttemptUpdateManyWithWhereWithoutQuizInput[]
|
|
deleteMany?: QuizAttemptScalarWhereInput | QuizAttemptScalarWhereInput[]
|
|
}
|
|
|
|
export type QuestionCreateoptionsFrInput = {
|
|
set: string[]
|
|
}
|
|
|
|
export type QuestionCreateoptionsEnInput = {
|
|
set: string[]
|
|
}
|
|
|
|
export type QuestionCreateoptionsEsInput = {
|
|
set: string[]
|
|
}
|
|
|
|
export type QuizCreateNestedOneWithoutQuestionsInput = {
|
|
create?: XOR<QuizCreateWithoutQuestionsInput, QuizUncheckedCreateWithoutQuestionsInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutQuestionsInput
|
|
connect?: QuizWhereUniqueInput
|
|
}
|
|
|
|
export type QuestionUpdateoptionsFrInput = {
|
|
set?: string[]
|
|
push?: string | string[]
|
|
}
|
|
|
|
export type QuestionUpdateoptionsEnInput = {
|
|
set?: string[]
|
|
push?: string | string[]
|
|
}
|
|
|
|
export type QuestionUpdateoptionsEsInput = {
|
|
set?: string[]
|
|
push?: string | string[]
|
|
}
|
|
|
|
export type QuizUpdateOneRequiredWithoutQuestionsNestedInput = {
|
|
create?: XOR<QuizCreateWithoutQuestionsInput, QuizUncheckedCreateWithoutQuestionsInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutQuestionsInput
|
|
upsert?: QuizUpsertWithoutQuestionsInput
|
|
connect?: QuizWhereUniqueInput
|
|
update?: XOR<XOR<QuizUpdateToOneWithWhereWithoutQuestionsInput, QuizUpdateWithoutQuestionsInput>, QuizUncheckedUpdateWithoutQuestionsInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutEnrollmentsInput = {
|
|
create?: XOR<UserCreateWithoutEnrollmentsInput, UserUncheckedCreateWithoutEnrollmentsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutEnrollmentsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type CourseCreateNestedOneWithoutEnrollmentsInput = {
|
|
create?: XOR<CourseCreateWithoutEnrollmentsInput, CourseUncheckedCreateWithoutEnrollmentsInput>
|
|
connectOrCreate?: CourseCreateOrConnectWithoutEnrollmentsInput
|
|
connect?: CourseWhereUniqueInput
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutEnrollmentsNestedInput = {
|
|
create?: XOR<UserCreateWithoutEnrollmentsInput, UserUncheckedCreateWithoutEnrollmentsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutEnrollmentsInput
|
|
upsert?: UserUpsertWithoutEnrollmentsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutEnrollmentsInput, UserUpdateWithoutEnrollmentsInput>, UserUncheckedUpdateWithoutEnrollmentsInput>
|
|
}
|
|
|
|
export type CourseUpdateOneRequiredWithoutEnrollmentsNestedInput = {
|
|
create?: XOR<CourseCreateWithoutEnrollmentsInput, CourseUncheckedCreateWithoutEnrollmentsInput>
|
|
connectOrCreate?: CourseCreateOrConnectWithoutEnrollmentsInput
|
|
upsert?: CourseUpsertWithoutEnrollmentsInput
|
|
connect?: CourseWhereUniqueInput
|
|
update?: XOR<XOR<CourseUpdateToOneWithWhereWithoutEnrollmentsInput, CourseUpdateWithoutEnrollmentsInput>, CourseUncheckedUpdateWithoutEnrollmentsInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutLessonProgressInput = {
|
|
create?: XOR<UserCreateWithoutLessonProgressInput, UserUncheckedCreateWithoutLessonProgressInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutLessonProgressInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type LessonCreateNestedOneWithoutLessonProgressInput = {
|
|
create?: XOR<LessonCreateWithoutLessonProgressInput, LessonUncheckedCreateWithoutLessonProgressInput>
|
|
connectOrCreate?: LessonCreateOrConnectWithoutLessonProgressInput
|
|
connect?: LessonWhereUniqueInput
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutLessonProgressNestedInput = {
|
|
create?: XOR<UserCreateWithoutLessonProgressInput, UserUncheckedCreateWithoutLessonProgressInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutLessonProgressInput
|
|
upsert?: UserUpsertWithoutLessonProgressInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutLessonProgressInput, UserUpdateWithoutLessonProgressInput>, UserUncheckedUpdateWithoutLessonProgressInput>
|
|
}
|
|
|
|
export type LessonUpdateOneRequiredWithoutLessonProgressNestedInput = {
|
|
create?: XOR<LessonCreateWithoutLessonProgressInput, LessonUncheckedCreateWithoutLessonProgressInput>
|
|
connectOrCreate?: LessonCreateOrConnectWithoutLessonProgressInput
|
|
upsert?: LessonUpsertWithoutLessonProgressInput
|
|
connect?: LessonWhereUniqueInput
|
|
update?: XOR<XOR<LessonUpdateToOneWithWhereWithoutLessonProgressInput, LessonUpdateWithoutLessonProgressInput>, LessonUncheckedUpdateWithoutLessonProgressInput>
|
|
}
|
|
|
|
export type QuizAttemptCreateanswersInput = {
|
|
set: number[]
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutQuizAttemptsInput = {
|
|
create?: XOR<UserCreateWithoutQuizAttemptsInput, UserUncheckedCreateWithoutQuizAttemptsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutQuizAttemptsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type QuizCreateNestedOneWithoutAttemptsInput = {
|
|
create?: XOR<QuizCreateWithoutAttemptsInput, QuizUncheckedCreateWithoutAttemptsInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutAttemptsInput
|
|
connect?: QuizWhereUniqueInput
|
|
}
|
|
|
|
export type QuizAttemptUpdateanswersInput = {
|
|
set?: number[]
|
|
push?: number | number[]
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutQuizAttemptsNestedInput = {
|
|
create?: XOR<UserCreateWithoutQuizAttemptsInput, UserUncheckedCreateWithoutQuizAttemptsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutQuizAttemptsInput
|
|
upsert?: UserUpsertWithoutQuizAttemptsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutQuizAttemptsInput, UserUpdateWithoutQuizAttemptsInput>, UserUncheckedUpdateWithoutQuizAttemptsInput>
|
|
}
|
|
|
|
export type QuizUpdateOneRequiredWithoutAttemptsNestedInput = {
|
|
create?: XOR<QuizCreateWithoutAttemptsInput, QuizUncheckedCreateWithoutAttemptsInput>
|
|
connectOrCreate?: QuizCreateOrConnectWithoutAttemptsInput
|
|
upsert?: QuizUpsertWithoutAttemptsInput
|
|
connect?: QuizWhereUniqueInput
|
|
update?: XOR<XOR<QuizUpdateToOneWithWhereWithoutAttemptsInput, QuizUpdateWithoutAttemptsInput>, QuizUncheckedUpdateWithoutAttemptsInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutCertificatesInput = {
|
|
create?: XOR<UserCreateWithoutCertificatesInput, UserUncheckedCreateWithoutCertificatesInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutCertificatesInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type CourseCreateNestedOneWithoutCertificatesInput = {
|
|
create?: XOR<CourseCreateWithoutCertificatesInput, CourseUncheckedCreateWithoutCertificatesInput>
|
|
connectOrCreate?: CourseCreateOrConnectWithoutCertificatesInput
|
|
connect?: CourseWhereUniqueInput
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutCertificatesNestedInput = {
|
|
create?: XOR<UserCreateWithoutCertificatesInput, UserUncheckedCreateWithoutCertificatesInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutCertificatesInput
|
|
upsert?: UserUpsertWithoutCertificatesInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutCertificatesInput, UserUpdateWithoutCertificatesInput>, UserUncheckedUpdateWithoutCertificatesInput>
|
|
}
|
|
|
|
export type CourseUpdateOneRequiredWithoutCertificatesNestedInput = {
|
|
create?: XOR<CourseCreateWithoutCertificatesInput, CourseUncheckedCreateWithoutCertificatesInput>
|
|
connectOrCreate?: CourseCreateOrConnectWithoutCertificatesInput
|
|
upsert?: CourseUpsertWithoutCertificatesInput
|
|
connect?: CourseWhereUniqueInput
|
|
update?: XOR<XOR<CourseUpdateToOneWithWhereWithoutCertificatesInput, CourseUpdateWithoutCertificatesInput>, CourseUncheckedUpdateWithoutCertificatesInput>
|
|
}
|
|
|
|
export type NestedStringFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel>
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
not?: NestedStringFilter<$PrismaModel> | string
|
|
}
|
|
|
|
export type NestedStringNullableFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
not?: NestedStringNullableFilter<$PrismaModel> | string | null
|
|
}
|
|
|
|
export type 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 NestedEnumRoleFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
|
|
}
|
|
|
|
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 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 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 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 NestedEnumRoleWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumRoleFilter<$PrismaModel>
|
|
_max?: NestedEnumRoleFilter<$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 NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel> | null
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedFloatNullableFilter<$PrismaModel>
|
|
_sum?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedIntNullableFilter<$PrismaModel>
|
|
_max?: NestedIntNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedFloatNullableFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel> | null
|
|
in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
|
|
notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
|
|
lt?: number | FloatFieldRefInput<$PrismaModel>
|
|
lte?: number | FloatFieldRefInput<$PrismaModel>
|
|
gt?: number | FloatFieldRefInput<$PrismaModel>
|
|
gte?: number | FloatFieldRefInput<$PrismaModel>
|
|
not?: NestedFloatNullableFilter<$PrismaModel> | number | null
|
|
}
|
|
|
|
export type NestedEnumCourseCategoryFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseCategory | EnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseCategoryFilter<$PrismaModel> | $Enums.CourseCategory
|
|
}
|
|
|
|
export type NestedEnumCourseLevelFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseLevel | EnumCourseLevelFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseLevelFilter<$PrismaModel> | $Enums.CourseLevel
|
|
}
|
|
|
|
export type NestedBoolFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolFilter<$PrismaModel> | boolean
|
|
}
|
|
|
|
export type NestedEnumCourseCategoryWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseCategory | EnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseCategory[] | ListEnumCourseCategoryFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseCategoryWithAggregatesFilter<$PrismaModel> | $Enums.CourseCategory
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumCourseCategoryFilter<$PrismaModel>
|
|
_max?: NestedEnumCourseCategoryFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumCourseLevelWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CourseLevel | EnumCourseLevelFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CourseLevel[] | ListEnumCourseLevelFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCourseLevelWithAggregatesFilter<$PrismaModel> | $Enums.CourseLevel
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumCourseLevelFilter<$PrismaModel>
|
|
_max?: NestedEnumCourseLevelFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedBoolFilter<$PrismaModel>
|
|
_max?: NestedBoolFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedIntFilter<$PrismaModel>
|
|
_max?: NestedIntFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedFloatFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
|
|
lt?: number | FloatFieldRefInput<$PrismaModel>
|
|
lte?: number | FloatFieldRefInput<$PrismaModel>
|
|
gt?: number | FloatFieldRefInput<$PrismaModel>
|
|
gte?: number | FloatFieldRefInput<$PrismaModel>
|
|
not?: NestedFloatFilter<$PrismaModel> | number
|
|
}
|
|
|
|
export type NestedEnumLessonTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.LessonType | EnumLessonTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumLessonTypeFilter<$PrismaModel> | $Enums.LessonType
|
|
}
|
|
|
|
export type NestedEnumLessonTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.LessonType | EnumLessonTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.LessonType[] | ListEnumLessonTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumLessonTypeWithAggregatesFilter<$PrismaModel> | $Enums.LessonType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumLessonTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumLessonTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type AccountCreateWithoutUserInput = {
|
|
id?: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token?: string | null
|
|
access_token?: string | null
|
|
expires_at?: number | null
|
|
token_type?: string | null
|
|
scope?: string | null
|
|
id_token?: string | null
|
|
session_state?: string | null
|
|
}
|
|
|
|
export type AccountUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token?: string | null
|
|
access_token?: string | null
|
|
expires_at?: number | null
|
|
token_type?: string | null
|
|
scope?: string | null
|
|
id_token?: string | null
|
|
session_state?: string | null
|
|
}
|
|
|
|
export type AccountCreateOrConnectWithoutUserInput = {
|
|
where: AccountWhereUniqueInput
|
|
create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type AccountCreateManyUserInputEnvelope = {
|
|
data: AccountCreateManyUserInput | AccountCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type SessionCreateWithoutUserInput = {
|
|
id?: string
|
|
sessionToken: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type SessionUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
sessionToken: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type SessionCreateOrConnectWithoutUserInput = {
|
|
where: SessionWhereUniqueInput
|
|
create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type SessionCreateManyUserInputEnvelope = {
|
|
data: SessionCreateManyUserInput | SessionCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type EnrollmentCreateWithoutUserInput = {
|
|
id?: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
course: CourseCreateNestedOneWithoutEnrollmentsInput
|
|
}
|
|
|
|
export type EnrollmentUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
courseId: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
}
|
|
|
|
export type EnrollmentCreateOrConnectWithoutUserInput = {
|
|
where: EnrollmentWhereUniqueInput
|
|
create: XOR<EnrollmentCreateWithoutUserInput, EnrollmentUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type EnrollmentCreateManyUserInputEnvelope = {
|
|
data: EnrollmentCreateManyUserInput | EnrollmentCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type LessonProgressCreateWithoutUserInput = {
|
|
id?: string
|
|
completedAt?: Date | string
|
|
lesson: LessonCreateNestedOneWithoutLessonProgressInput
|
|
}
|
|
|
|
export type LessonProgressUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
lessonId: string
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type LessonProgressCreateOrConnectWithoutUserInput = {
|
|
where: LessonProgressWhereUniqueInput
|
|
create: XOR<LessonProgressCreateWithoutUserInput, LessonProgressUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type LessonProgressCreateManyUserInputEnvelope = {
|
|
data: LessonProgressCreateManyUserInput | LessonProgressCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type QuizAttemptCreateWithoutUserInput = {
|
|
id?: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
quiz: QuizCreateNestedOneWithoutAttemptsInput
|
|
}
|
|
|
|
export type QuizAttemptUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
quizId: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type QuizAttemptCreateOrConnectWithoutUserInput = {
|
|
where: QuizAttemptWhereUniqueInput
|
|
create: XOR<QuizAttemptCreateWithoutUserInput, QuizAttemptUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type QuizAttemptCreateManyUserInputEnvelope = {
|
|
data: QuizAttemptCreateManyUserInput | QuizAttemptCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type CertificateCreateWithoutUserInput = {
|
|
id?: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
course: CourseCreateNestedOneWithoutCertificatesInput
|
|
}
|
|
|
|
export type CertificateUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
courseId: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type CertificateCreateOrConnectWithoutUserInput = {
|
|
where: CertificateWhereUniqueInput
|
|
create: XOR<CertificateCreateWithoutUserInput, CertificateUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type CertificateCreateManyUserInputEnvelope = {
|
|
data: CertificateCreateManyUserInput | CertificateCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type AccountUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: AccountWhereUniqueInput
|
|
update: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
|
|
create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type AccountUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: AccountWhereUniqueInput
|
|
data: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type AccountUpdateManyWithWhereWithoutUserInput = {
|
|
where: AccountScalarWhereInput
|
|
data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type AccountScalarWhereInput = {
|
|
AND?: AccountScalarWhereInput | AccountScalarWhereInput[]
|
|
OR?: AccountScalarWhereInput[]
|
|
NOT?: AccountScalarWhereInput | AccountScalarWhereInput[]
|
|
id?: StringFilter<"Account"> | string
|
|
userId?: StringFilter<"Account"> | string
|
|
type?: StringFilter<"Account"> | string
|
|
provider?: StringFilter<"Account"> | string
|
|
providerAccountId?: StringFilter<"Account"> | string
|
|
refresh_token?: StringNullableFilter<"Account"> | string | null
|
|
access_token?: StringNullableFilter<"Account"> | string | null
|
|
expires_at?: IntNullableFilter<"Account"> | number | null
|
|
token_type?: StringNullableFilter<"Account"> | string | null
|
|
scope?: StringNullableFilter<"Account"> | string | null
|
|
id_token?: StringNullableFilter<"Account"> | string | null
|
|
session_state?: StringNullableFilter<"Account"> | string | null
|
|
}
|
|
|
|
export type SessionUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: SessionWhereUniqueInput
|
|
update: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
|
|
create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type SessionUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: SessionWhereUniqueInput
|
|
data: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type SessionUpdateManyWithWhereWithoutUserInput = {
|
|
where: SessionScalarWhereInput
|
|
data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type SessionScalarWhereInput = {
|
|
AND?: SessionScalarWhereInput | SessionScalarWhereInput[]
|
|
OR?: SessionScalarWhereInput[]
|
|
NOT?: SessionScalarWhereInput | SessionScalarWhereInput[]
|
|
id?: StringFilter<"Session"> | string
|
|
sessionToken?: StringFilter<"Session"> | string
|
|
userId?: StringFilter<"Session"> | string
|
|
expires?: DateTimeFilter<"Session"> | Date | string
|
|
}
|
|
|
|
export type EnrollmentUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: EnrollmentWhereUniqueInput
|
|
update: XOR<EnrollmentUpdateWithoutUserInput, EnrollmentUncheckedUpdateWithoutUserInput>
|
|
create: XOR<EnrollmentCreateWithoutUserInput, EnrollmentUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type EnrollmentUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: EnrollmentWhereUniqueInput
|
|
data: XOR<EnrollmentUpdateWithoutUserInput, EnrollmentUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type EnrollmentUpdateManyWithWhereWithoutUserInput = {
|
|
where: EnrollmentScalarWhereInput
|
|
data: XOR<EnrollmentUpdateManyMutationInput, EnrollmentUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type EnrollmentScalarWhereInput = {
|
|
AND?: EnrollmentScalarWhereInput | EnrollmentScalarWhereInput[]
|
|
OR?: EnrollmentScalarWhereInput[]
|
|
NOT?: EnrollmentScalarWhereInput | EnrollmentScalarWhereInput[]
|
|
id?: StringFilter<"Enrollment"> | string
|
|
userId?: StringFilter<"Enrollment"> | string
|
|
courseId?: StringFilter<"Enrollment"> | string
|
|
enrolledAt?: DateTimeFilter<"Enrollment"> | Date | string
|
|
completedAt?: DateTimeNullableFilter<"Enrollment"> | Date | string | null
|
|
}
|
|
|
|
export type LessonProgressUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: LessonProgressWhereUniqueInput
|
|
update: XOR<LessonProgressUpdateWithoutUserInput, LessonProgressUncheckedUpdateWithoutUserInput>
|
|
create: XOR<LessonProgressCreateWithoutUserInput, LessonProgressUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type LessonProgressUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: LessonProgressWhereUniqueInput
|
|
data: XOR<LessonProgressUpdateWithoutUserInput, LessonProgressUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type LessonProgressUpdateManyWithWhereWithoutUserInput = {
|
|
where: LessonProgressScalarWhereInput
|
|
data: XOR<LessonProgressUpdateManyMutationInput, LessonProgressUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type LessonProgressScalarWhereInput = {
|
|
AND?: LessonProgressScalarWhereInput | LessonProgressScalarWhereInput[]
|
|
OR?: LessonProgressScalarWhereInput[]
|
|
NOT?: LessonProgressScalarWhereInput | LessonProgressScalarWhereInput[]
|
|
id?: StringFilter<"LessonProgress"> | string
|
|
userId?: StringFilter<"LessonProgress"> | string
|
|
lessonId?: StringFilter<"LessonProgress"> | string
|
|
completedAt?: DateTimeFilter<"LessonProgress"> | Date | string
|
|
}
|
|
|
|
export type QuizAttemptUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: QuizAttemptWhereUniqueInput
|
|
update: XOR<QuizAttemptUpdateWithoutUserInput, QuizAttemptUncheckedUpdateWithoutUserInput>
|
|
create: XOR<QuizAttemptCreateWithoutUserInput, QuizAttemptUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type QuizAttemptUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: QuizAttemptWhereUniqueInput
|
|
data: XOR<QuizAttemptUpdateWithoutUserInput, QuizAttemptUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type QuizAttemptUpdateManyWithWhereWithoutUserInput = {
|
|
where: QuizAttemptScalarWhereInput
|
|
data: XOR<QuizAttemptUpdateManyMutationInput, QuizAttemptUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type QuizAttemptScalarWhereInput = {
|
|
AND?: QuizAttemptScalarWhereInput | QuizAttemptScalarWhereInput[]
|
|
OR?: QuizAttemptScalarWhereInput[]
|
|
NOT?: QuizAttemptScalarWhereInput | QuizAttemptScalarWhereInput[]
|
|
id?: StringFilter<"QuizAttempt"> | string
|
|
userId?: StringFilter<"QuizAttempt"> | string
|
|
quizId?: StringFilter<"QuizAttempt"> | string
|
|
score?: IntFilter<"QuizAttempt"> | number
|
|
passed?: BoolFilter<"QuizAttempt"> | boolean
|
|
answers?: IntNullableListFilter<"QuizAttempt">
|
|
completedAt?: DateTimeFilter<"QuizAttempt"> | Date | string
|
|
}
|
|
|
|
export type CertificateUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: CertificateWhereUniqueInput
|
|
update: XOR<CertificateUpdateWithoutUserInput, CertificateUncheckedUpdateWithoutUserInput>
|
|
create: XOR<CertificateCreateWithoutUserInput, CertificateUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type CertificateUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: CertificateWhereUniqueInput
|
|
data: XOR<CertificateUpdateWithoutUserInput, CertificateUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type CertificateUpdateManyWithWhereWithoutUserInput = {
|
|
where: CertificateScalarWhereInput
|
|
data: XOR<CertificateUpdateManyMutationInput, CertificateUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type CertificateScalarWhereInput = {
|
|
AND?: CertificateScalarWhereInput | CertificateScalarWhereInput[]
|
|
OR?: CertificateScalarWhereInput[]
|
|
NOT?: CertificateScalarWhereInput | CertificateScalarWhereInput[]
|
|
id?: StringFilter<"Certificate"> | string
|
|
userId?: StringFilter<"Certificate"> | string
|
|
courseId?: StringFilter<"Certificate"> | string
|
|
issuedAt?: DateTimeFilter<"Certificate"> | Date | string
|
|
pdfUrl?: StringNullableFilter<"Certificate"> | string | null
|
|
isPaid?: BoolFilter<"Certificate"> | boolean
|
|
}
|
|
|
|
export type UserCreateWithoutAccountsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
sessions?: SessionCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutAccountsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptUncheckedCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutAccountsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutAccountsInput = {
|
|
update: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
|
|
create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutAccountsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutAccountsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
sessions?: SessionUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutAccountsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUncheckedUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserCreateWithoutSessionsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutSessionsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptUncheckedCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutSessionsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutSessionsInput = {
|
|
update: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
|
|
create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutSessionsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutSessionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutSessionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUncheckedUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type ModuleCreateWithoutCourseInput = {
|
|
id?: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
lessons?: LessonCreateNestedManyWithoutModuleInput
|
|
quiz?: QuizCreateNestedOneWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleUncheckedCreateWithoutCourseInput = {
|
|
id?: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
lessons?: LessonUncheckedCreateNestedManyWithoutModuleInput
|
|
quiz?: QuizUncheckedCreateNestedOneWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleCreateOrConnectWithoutCourseInput = {
|
|
where: ModuleWhereUniqueInput
|
|
create: XOR<ModuleCreateWithoutCourseInput, ModuleUncheckedCreateWithoutCourseInput>
|
|
}
|
|
|
|
export type ModuleCreateManyCourseInputEnvelope = {
|
|
data: ModuleCreateManyCourseInput | ModuleCreateManyCourseInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type EnrollmentCreateWithoutCourseInput = {
|
|
id?: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
user: UserCreateNestedOneWithoutEnrollmentsInput
|
|
}
|
|
|
|
export type EnrollmentUncheckedCreateWithoutCourseInput = {
|
|
id?: string
|
|
userId: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
}
|
|
|
|
export type EnrollmentCreateOrConnectWithoutCourseInput = {
|
|
where: EnrollmentWhereUniqueInput
|
|
create: XOR<EnrollmentCreateWithoutCourseInput, EnrollmentUncheckedCreateWithoutCourseInput>
|
|
}
|
|
|
|
export type EnrollmentCreateManyCourseInputEnvelope = {
|
|
data: EnrollmentCreateManyCourseInput | EnrollmentCreateManyCourseInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type CertificateCreateWithoutCourseInput = {
|
|
id?: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
user: UserCreateNestedOneWithoutCertificatesInput
|
|
}
|
|
|
|
export type CertificateUncheckedCreateWithoutCourseInput = {
|
|
id?: string
|
|
userId: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type CertificateCreateOrConnectWithoutCourseInput = {
|
|
where: CertificateWhereUniqueInput
|
|
create: XOR<CertificateCreateWithoutCourseInput, CertificateUncheckedCreateWithoutCourseInput>
|
|
}
|
|
|
|
export type CertificateCreateManyCourseInputEnvelope = {
|
|
data: CertificateCreateManyCourseInput | CertificateCreateManyCourseInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ModuleUpsertWithWhereUniqueWithoutCourseInput = {
|
|
where: ModuleWhereUniqueInput
|
|
update: XOR<ModuleUpdateWithoutCourseInput, ModuleUncheckedUpdateWithoutCourseInput>
|
|
create: XOR<ModuleCreateWithoutCourseInput, ModuleUncheckedCreateWithoutCourseInput>
|
|
}
|
|
|
|
export type ModuleUpdateWithWhereUniqueWithoutCourseInput = {
|
|
where: ModuleWhereUniqueInput
|
|
data: XOR<ModuleUpdateWithoutCourseInput, ModuleUncheckedUpdateWithoutCourseInput>
|
|
}
|
|
|
|
export type ModuleUpdateManyWithWhereWithoutCourseInput = {
|
|
where: ModuleScalarWhereInput
|
|
data: XOR<ModuleUpdateManyMutationInput, ModuleUncheckedUpdateManyWithoutCourseInput>
|
|
}
|
|
|
|
export type ModuleScalarWhereInput = {
|
|
AND?: ModuleScalarWhereInput | ModuleScalarWhereInput[]
|
|
OR?: ModuleScalarWhereInput[]
|
|
NOT?: ModuleScalarWhereInput | ModuleScalarWhereInput[]
|
|
id?: StringFilter<"Module"> | string
|
|
courseId?: StringFilter<"Module"> | string
|
|
order?: IntFilter<"Module"> | number
|
|
titleFr?: StringFilter<"Module"> | string
|
|
titleEn?: StringFilter<"Module"> | string
|
|
titleEs?: StringFilter<"Module"> | string
|
|
}
|
|
|
|
export type EnrollmentUpsertWithWhereUniqueWithoutCourseInput = {
|
|
where: EnrollmentWhereUniqueInput
|
|
update: XOR<EnrollmentUpdateWithoutCourseInput, EnrollmentUncheckedUpdateWithoutCourseInput>
|
|
create: XOR<EnrollmentCreateWithoutCourseInput, EnrollmentUncheckedCreateWithoutCourseInput>
|
|
}
|
|
|
|
export type EnrollmentUpdateWithWhereUniqueWithoutCourseInput = {
|
|
where: EnrollmentWhereUniqueInput
|
|
data: XOR<EnrollmentUpdateWithoutCourseInput, EnrollmentUncheckedUpdateWithoutCourseInput>
|
|
}
|
|
|
|
export type EnrollmentUpdateManyWithWhereWithoutCourseInput = {
|
|
where: EnrollmentScalarWhereInput
|
|
data: XOR<EnrollmentUpdateManyMutationInput, EnrollmentUncheckedUpdateManyWithoutCourseInput>
|
|
}
|
|
|
|
export type CertificateUpsertWithWhereUniqueWithoutCourseInput = {
|
|
where: CertificateWhereUniqueInput
|
|
update: XOR<CertificateUpdateWithoutCourseInput, CertificateUncheckedUpdateWithoutCourseInput>
|
|
create: XOR<CertificateCreateWithoutCourseInput, CertificateUncheckedCreateWithoutCourseInput>
|
|
}
|
|
|
|
export type CertificateUpdateWithWhereUniqueWithoutCourseInput = {
|
|
where: CertificateWhereUniqueInput
|
|
data: XOR<CertificateUpdateWithoutCourseInput, CertificateUncheckedUpdateWithoutCourseInput>
|
|
}
|
|
|
|
export type CertificateUpdateManyWithWhereWithoutCourseInput = {
|
|
where: CertificateScalarWhereInput
|
|
data: XOR<CertificateUpdateManyMutationInput, CertificateUncheckedUpdateManyWithoutCourseInput>
|
|
}
|
|
|
|
export type CourseCreateWithoutModulesInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
enrollments?: EnrollmentCreateNestedManyWithoutCourseInput
|
|
certificates?: CertificateCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseUncheckedCreateWithoutModulesInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutCourseInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseCreateOrConnectWithoutModulesInput = {
|
|
where: CourseWhereUniqueInput
|
|
create: XOR<CourseCreateWithoutModulesInput, CourseUncheckedCreateWithoutModulesInput>
|
|
}
|
|
|
|
export type LessonCreateWithoutModuleInput = {
|
|
id?: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutLessonInput
|
|
}
|
|
|
|
export type LessonUncheckedCreateWithoutModuleInput = {
|
|
id?: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutLessonInput
|
|
}
|
|
|
|
export type LessonCreateOrConnectWithoutModuleInput = {
|
|
where: LessonWhereUniqueInput
|
|
create: XOR<LessonCreateWithoutModuleInput, LessonUncheckedCreateWithoutModuleInput>
|
|
}
|
|
|
|
export type LessonCreateManyModuleInputEnvelope = {
|
|
data: LessonCreateManyModuleInput | LessonCreateManyModuleInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type QuizCreateWithoutModuleInput = {
|
|
id?: string
|
|
passMark?: number
|
|
questions?: QuestionCreateNestedManyWithoutQuizInput
|
|
attempts?: QuizAttemptCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizUncheckedCreateWithoutModuleInput = {
|
|
id?: string
|
|
passMark?: number
|
|
questions?: QuestionUncheckedCreateNestedManyWithoutQuizInput
|
|
attempts?: QuizAttemptUncheckedCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizCreateOrConnectWithoutModuleInput = {
|
|
where: QuizWhereUniqueInput
|
|
create: XOR<QuizCreateWithoutModuleInput, QuizUncheckedCreateWithoutModuleInput>
|
|
}
|
|
|
|
export type CourseUpsertWithoutModulesInput = {
|
|
update: XOR<CourseUpdateWithoutModulesInput, CourseUncheckedUpdateWithoutModulesInput>
|
|
create: XOR<CourseCreateWithoutModulesInput, CourseUncheckedCreateWithoutModulesInput>
|
|
where?: CourseWhereInput
|
|
}
|
|
|
|
export type CourseUpdateToOneWithWhereWithoutModulesInput = {
|
|
where?: CourseWhereInput
|
|
data: XOR<CourseUpdateWithoutModulesInput, CourseUncheckedUpdateWithoutModulesInput>
|
|
}
|
|
|
|
export type CourseUpdateWithoutModulesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
enrollments?: EnrollmentUpdateManyWithoutCourseNestedInput
|
|
certificates?: CertificateUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type CourseUncheckedUpdateWithoutModulesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutCourseNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type LessonUpsertWithWhereUniqueWithoutModuleInput = {
|
|
where: LessonWhereUniqueInput
|
|
update: XOR<LessonUpdateWithoutModuleInput, LessonUncheckedUpdateWithoutModuleInput>
|
|
create: XOR<LessonCreateWithoutModuleInput, LessonUncheckedCreateWithoutModuleInput>
|
|
}
|
|
|
|
export type LessonUpdateWithWhereUniqueWithoutModuleInput = {
|
|
where: LessonWhereUniqueInput
|
|
data: XOR<LessonUpdateWithoutModuleInput, LessonUncheckedUpdateWithoutModuleInput>
|
|
}
|
|
|
|
export type LessonUpdateManyWithWhereWithoutModuleInput = {
|
|
where: LessonScalarWhereInput
|
|
data: XOR<LessonUpdateManyMutationInput, LessonUncheckedUpdateManyWithoutModuleInput>
|
|
}
|
|
|
|
export type LessonScalarWhereInput = {
|
|
AND?: LessonScalarWhereInput | LessonScalarWhereInput[]
|
|
OR?: LessonScalarWhereInput[]
|
|
NOT?: LessonScalarWhereInput | LessonScalarWhereInput[]
|
|
id?: StringFilter<"Lesson"> | string
|
|
moduleId?: StringFilter<"Lesson"> | string
|
|
order?: IntFilter<"Lesson"> | number
|
|
type?: EnumLessonTypeFilter<"Lesson"> | $Enums.LessonType
|
|
videoUrl?: StringNullableFilter<"Lesson"> | string | null
|
|
duration?: IntNullableFilter<"Lesson"> | number | null
|
|
titleFr?: StringFilter<"Lesson"> | string
|
|
titleEn?: StringFilter<"Lesson"> | string
|
|
titleEs?: StringFilter<"Lesson"> | string
|
|
contentFr?: StringNullableFilter<"Lesson"> | string | null
|
|
contentEn?: StringNullableFilter<"Lesson"> | string | null
|
|
contentEs?: StringNullableFilter<"Lesson"> | string | null
|
|
}
|
|
|
|
export type QuizUpsertWithoutModuleInput = {
|
|
update: XOR<QuizUpdateWithoutModuleInput, QuizUncheckedUpdateWithoutModuleInput>
|
|
create: XOR<QuizCreateWithoutModuleInput, QuizUncheckedCreateWithoutModuleInput>
|
|
where?: QuizWhereInput
|
|
}
|
|
|
|
export type QuizUpdateToOneWithWhereWithoutModuleInput = {
|
|
where?: QuizWhereInput
|
|
data: XOR<QuizUpdateWithoutModuleInput, QuizUncheckedUpdateWithoutModuleInput>
|
|
}
|
|
|
|
export type QuizUpdateWithoutModuleInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
questions?: QuestionUpdateManyWithoutQuizNestedInput
|
|
attempts?: QuizAttemptUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type QuizUncheckedUpdateWithoutModuleInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
questions?: QuestionUncheckedUpdateManyWithoutQuizNestedInput
|
|
attempts?: QuizAttemptUncheckedUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type ModuleCreateWithoutLessonsInput = {
|
|
id?: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
course: CourseCreateNestedOneWithoutModulesInput
|
|
quiz?: QuizCreateNestedOneWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleUncheckedCreateWithoutLessonsInput = {
|
|
id?: string
|
|
courseId: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
quiz?: QuizUncheckedCreateNestedOneWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleCreateOrConnectWithoutLessonsInput = {
|
|
where: ModuleWhereUniqueInput
|
|
create: XOR<ModuleCreateWithoutLessonsInput, ModuleUncheckedCreateWithoutLessonsInput>
|
|
}
|
|
|
|
export type LessonProgressCreateWithoutLessonInput = {
|
|
id?: string
|
|
completedAt?: Date | string
|
|
user: UserCreateNestedOneWithoutLessonProgressInput
|
|
}
|
|
|
|
export type LessonProgressUncheckedCreateWithoutLessonInput = {
|
|
id?: string
|
|
userId: string
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type LessonProgressCreateOrConnectWithoutLessonInput = {
|
|
where: LessonProgressWhereUniqueInput
|
|
create: XOR<LessonProgressCreateWithoutLessonInput, LessonProgressUncheckedCreateWithoutLessonInput>
|
|
}
|
|
|
|
export type LessonProgressCreateManyLessonInputEnvelope = {
|
|
data: LessonProgressCreateManyLessonInput | LessonProgressCreateManyLessonInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ModuleUpsertWithoutLessonsInput = {
|
|
update: XOR<ModuleUpdateWithoutLessonsInput, ModuleUncheckedUpdateWithoutLessonsInput>
|
|
create: XOR<ModuleCreateWithoutLessonsInput, ModuleUncheckedCreateWithoutLessonsInput>
|
|
where?: ModuleWhereInput
|
|
}
|
|
|
|
export type ModuleUpdateToOneWithWhereWithoutLessonsInput = {
|
|
where?: ModuleWhereInput
|
|
data: XOR<ModuleUpdateWithoutLessonsInput, ModuleUncheckedUpdateWithoutLessonsInput>
|
|
}
|
|
|
|
export type ModuleUpdateWithoutLessonsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
course?: CourseUpdateOneRequiredWithoutModulesNestedInput
|
|
quiz?: QuizUpdateOneWithoutModuleNestedInput
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateWithoutLessonsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
quiz?: QuizUncheckedUpdateOneWithoutModuleNestedInput
|
|
}
|
|
|
|
export type LessonProgressUpsertWithWhereUniqueWithoutLessonInput = {
|
|
where: LessonProgressWhereUniqueInput
|
|
update: XOR<LessonProgressUpdateWithoutLessonInput, LessonProgressUncheckedUpdateWithoutLessonInput>
|
|
create: XOR<LessonProgressCreateWithoutLessonInput, LessonProgressUncheckedCreateWithoutLessonInput>
|
|
}
|
|
|
|
export type LessonProgressUpdateWithWhereUniqueWithoutLessonInput = {
|
|
where: LessonProgressWhereUniqueInput
|
|
data: XOR<LessonProgressUpdateWithoutLessonInput, LessonProgressUncheckedUpdateWithoutLessonInput>
|
|
}
|
|
|
|
export type LessonProgressUpdateManyWithWhereWithoutLessonInput = {
|
|
where: LessonProgressScalarWhereInput
|
|
data: XOR<LessonProgressUpdateManyMutationInput, LessonProgressUncheckedUpdateManyWithoutLessonInput>
|
|
}
|
|
|
|
export type ModuleCreateWithoutQuizInput = {
|
|
id?: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
course: CourseCreateNestedOneWithoutModulesInput
|
|
lessons?: LessonCreateNestedManyWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleUncheckedCreateWithoutQuizInput = {
|
|
id?: string
|
|
courseId: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
lessons?: LessonUncheckedCreateNestedManyWithoutModuleInput
|
|
}
|
|
|
|
export type ModuleCreateOrConnectWithoutQuizInput = {
|
|
where: ModuleWhereUniqueInput
|
|
create: XOR<ModuleCreateWithoutQuizInput, ModuleUncheckedCreateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuestionCreateWithoutQuizInput = {
|
|
id?: string
|
|
order?: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr?: QuestionCreateoptionsFrInput | string[]
|
|
optionsEn?: QuestionCreateoptionsEnInput | string[]
|
|
optionsEs?: QuestionCreateoptionsEsInput | string[]
|
|
correctIndex: number
|
|
}
|
|
|
|
export type QuestionUncheckedCreateWithoutQuizInput = {
|
|
id?: string
|
|
order?: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr?: QuestionCreateoptionsFrInput | string[]
|
|
optionsEn?: QuestionCreateoptionsEnInput | string[]
|
|
optionsEs?: QuestionCreateoptionsEsInput | string[]
|
|
correctIndex: number
|
|
}
|
|
|
|
export type QuestionCreateOrConnectWithoutQuizInput = {
|
|
where: QuestionWhereUniqueInput
|
|
create: XOR<QuestionCreateWithoutQuizInput, QuestionUncheckedCreateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuestionCreateManyQuizInputEnvelope = {
|
|
data: QuestionCreateManyQuizInput | QuestionCreateManyQuizInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type QuizAttemptCreateWithoutQuizInput = {
|
|
id?: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
user: UserCreateNestedOneWithoutQuizAttemptsInput
|
|
}
|
|
|
|
export type QuizAttemptUncheckedCreateWithoutQuizInput = {
|
|
id?: string
|
|
userId: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type QuizAttemptCreateOrConnectWithoutQuizInput = {
|
|
where: QuizAttemptWhereUniqueInput
|
|
create: XOR<QuizAttemptCreateWithoutQuizInput, QuizAttemptUncheckedCreateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuizAttemptCreateManyQuizInputEnvelope = {
|
|
data: QuizAttemptCreateManyQuizInput | QuizAttemptCreateManyQuizInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ModuleUpsertWithoutQuizInput = {
|
|
update: XOR<ModuleUpdateWithoutQuizInput, ModuleUncheckedUpdateWithoutQuizInput>
|
|
create: XOR<ModuleCreateWithoutQuizInput, ModuleUncheckedCreateWithoutQuizInput>
|
|
where?: ModuleWhereInput
|
|
}
|
|
|
|
export type ModuleUpdateToOneWithWhereWithoutQuizInput = {
|
|
where?: ModuleWhereInput
|
|
data: XOR<ModuleUpdateWithoutQuizInput, ModuleUncheckedUpdateWithoutQuizInput>
|
|
}
|
|
|
|
export type ModuleUpdateWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
course?: CourseUpdateOneRequiredWithoutModulesNestedInput
|
|
lessons?: LessonUpdateManyWithoutModuleNestedInput
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
lessons?: LessonUncheckedUpdateManyWithoutModuleNestedInput
|
|
}
|
|
|
|
export type QuestionUpsertWithWhereUniqueWithoutQuizInput = {
|
|
where: QuestionWhereUniqueInput
|
|
update: XOR<QuestionUpdateWithoutQuizInput, QuestionUncheckedUpdateWithoutQuizInput>
|
|
create: XOR<QuestionCreateWithoutQuizInput, QuestionUncheckedCreateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuestionUpdateWithWhereUniqueWithoutQuizInput = {
|
|
where: QuestionWhereUniqueInput
|
|
data: XOR<QuestionUpdateWithoutQuizInput, QuestionUncheckedUpdateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuestionUpdateManyWithWhereWithoutQuizInput = {
|
|
where: QuestionScalarWhereInput
|
|
data: XOR<QuestionUpdateManyMutationInput, QuestionUncheckedUpdateManyWithoutQuizInput>
|
|
}
|
|
|
|
export type QuestionScalarWhereInput = {
|
|
AND?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
|
|
OR?: QuestionScalarWhereInput[]
|
|
NOT?: QuestionScalarWhereInput | QuestionScalarWhereInput[]
|
|
id?: StringFilter<"Question"> | string
|
|
quizId?: StringFilter<"Question"> | string
|
|
order?: IntFilter<"Question"> | number
|
|
textFr?: StringFilter<"Question"> | string
|
|
textEn?: StringFilter<"Question"> | string
|
|
textEs?: StringFilter<"Question"> | string
|
|
optionsFr?: StringNullableListFilter<"Question">
|
|
optionsEn?: StringNullableListFilter<"Question">
|
|
optionsEs?: StringNullableListFilter<"Question">
|
|
correctIndex?: IntFilter<"Question"> | number
|
|
}
|
|
|
|
export type QuizAttemptUpsertWithWhereUniqueWithoutQuizInput = {
|
|
where: QuizAttemptWhereUniqueInput
|
|
update: XOR<QuizAttemptUpdateWithoutQuizInput, QuizAttemptUncheckedUpdateWithoutQuizInput>
|
|
create: XOR<QuizAttemptCreateWithoutQuizInput, QuizAttemptUncheckedCreateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuizAttemptUpdateWithWhereUniqueWithoutQuizInput = {
|
|
where: QuizAttemptWhereUniqueInput
|
|
data: XOR<QuizAttemptUpdateWithoutQuizInput, QuizAttemptUncheckedUpdateWithoutQuizInput>
|
|
}
|
|
|
|
export type QuizAttemptUpdateManyWithWhereWithoutQuizInput = {
|
|
where: QuizAttemptScalarWhereInput
|
|
data: XOR<QuizAttemptUpdateManyMutationInput, QuizAttemptUncheckedUpdateManyWithoutQuizInput>
|
|
}
|
|
|
|
export type QuizCreateWithoutQuestionsInput = {
|
|
id?: string
|
|
passMark?: number
|
|
module: ModuleCreateNestedOneWithoutQuizInput
|
|
attempts?: QuizAttemptCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizUncheckedCreateWithoutQuestionsInput = {
|
|
id?: string
|
|
moduleId: string
|
|
passMark?: number
|
|
attempts?: QuizAttemptUncheckedCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizCreateOrConnectWithoutQuestionsInput = {
|
|
where: QuizWhereUniqueInput
|
|
create: XOR<QuizCreateWithoutQuestionsInput, QuizUncheckedCreateWithoutQuestionsInput>
|
|
}
|
|
|
|
export type QuizUpsertWithoutQuestionsInput = {
|
|
update: XOR<QuizUpdateWithoutQuestionsInput, QuizUncheckedUpdateWithoutQuestionsInput>
|
|
create: XOR<QuizCreateWithoutQuestionsInput, QuizUncheckedCreateWithoutQuestionsInput>
|
|
where?: QuizWhereInput
|
|
}
|
|
|
|
export type QuizUpdateToOneWithWhereWithoutQuestionsInput = {
|
|
where?: QuizWhereInput
|
|
data: XOR<QuizUpdateWithoutQuestionsInput, QuizUncheckedUpdateWithoutQuestionsInput>
|
|
}
|
|
|
|
export type QuizUpdateWithoutQuestionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
module?: ModuleUpdateOneRequiredWithoutQuizNestedInput
|
|
attempts?: QuizAttemptUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type QuizUncheckedUpdateWithoutQuestionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
attempts?: QuizAttemptUncheckedUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type UserCreateWithoutEnrollmentsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountCreateNestedManyWithoutUserInput
|
|
sessions?: SessionCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutEnrollmentsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
|
|
sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptUncheckedCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutEnrollmentsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutEnrollmentsInput, UserUncheckedCreateWithoutEnrollmentsInput>
|
|
}
|
|
|
|
export type CourseCreateWithoutEnrollmentsInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
modules?: ModuleCreateNestedManyWithoutCourseInput
|
|
certificates?: CertificateCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseUncheckedCreateWithoutEnrollmentsInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
modules?: ModuleUncheckedCreateNestedManyWithoutCourseInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseCreateOrConnectWithoutEnrollmentsInput = {
|
|
where: CourseWhereUniqueInput
|
|
create: XOR<CourseCreateWithoutEnrollmentsInput, CourseUncheckedCreateWithoutEnrollmentsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutEnrollmentsInput = {
|
|
update: XOR<UserUpdateWithoutEnrollmentsInput, UserUncheckedUpdateWithoutEnrollmentsInput>
|
|
create: XOR<UserCreateWithoutEnrollmentsInput, UserUncheckedCreateWithoutEnrollmentsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutEnrollmentsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutEnrollmentsInput, UserUncheckedUpdateWithoutEnrollmentsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutEnrollmentsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutEnrollmentsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUncheckedUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type CourseUpsertWithoutEnrollmentsInput = {
|
|
update: XOR<CourseUpdateWithoutEnrollmentsInput, CourseUncheckedUpdateWithoutEnrollmentsInput>
|
|
create: XOR<CourseCreateWithoutEnrollmentsInput, CourseUncheckedCreateWithoutEnrollmentsInput>
|
|
where?: CourseWhereInput
|
|
}
|
|
|
|
export type CourseUpdateToOneWithWhereWithoutEnrollmentsInput = {
|
|
where?: CourseWhereInput
|
|
data: XOR<CourseUpdateWithoutEnrollmentsInput, CourseUncheckedUpdateWithoutEnrollmentsInput>
|
|
}
|
|
|
|
export type CourseUpdateWithoutEnrollmentsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
modules?: ModuleUpdateManyWithoutCourseNestedInput
|
|
certificates?: CertificateUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type CourseUncheckedUpdateWithoutEnrollmentsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
modules?: ModuleUncheckedUpdateManyWithoutCourseNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type UserCreateWithoutLessonProgressInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountCreateNestedManyWithoutUserInput
|
|
sessions?: SessionCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutLessonProgressInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
|
|
sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptUncheckedCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutLessonProgressInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutLessonProgressInput, UserUncheckedCreateWithoutLessonProgressInput>
|
|
}
|
|
|
|
export type LessonCreateWithoutLessonProgressInput = {
|
|
id?: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
module: ModuleCreateNestedOneWithoutLessonsInput
|
|
}
|
|
|
|
export type LessonUncheckedCreateWithoutLessonProgressInput = {
|
|
id?: string
|
|
moduleId: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
}
|
|
|
|
export type LessonCreateOrConnectWithoutLessonProgressInput = {
|
|
where: LessonWhereUniqueInput
|
|
create: XOR<LessonCreateWithoutLessonProgressInput, LessonUncheckedCreateWithoutLessonProgressInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutLessonProgressInput = {
|
|
update: XOR<UserUpdateWithoutLessonProgressInput, UserUncheckedUpdateWithoutLessonProgressInput>
|
|
create: XOR<UserCreateWithoutLessonProgressInput, UserUncheckedCreateWithoutLessonProgressInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutLessonProgressInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutLessonProgressInput, UserUncheckedUpdateWithoutLessonProgressInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutLessonProgressInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutLessonProgressInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUncheckedUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type LessonUpsertWithoutLessonProgressInput = {
|
|
update: XOR<LessonUpdateWithoutLessonProgressInput, LessonUncheckedUpdateWithoutLessonProgressInput>
|
|
create: XOR<LessonCreateWithoutLessonProgressInput, LessonUncheckedCreateWithoutLessonProgressInput>
|
|
where?: LessonWhereInput
|
|
}
|
|
|
|
export type LessonUpdateToOneWithWhereWithoutLessonProgressInput = {
|
|
where?: LessonWhereInput
|
|
data: XOR<LessonUpdateWithoutLessonProgressInput, LessonUncheckedUpdateWithoutLessonProgressInput>
|
|
}
|
|
|
|
export type LessonUpdateWithoutLessonProgressInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
module?: ModuleUpdateOneRequiredWithoutLessonsNestedInput
|
|
}
|
|
|
|
export type LessonUncheckedUpdateWithoutLessonProgressInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type UserCreateWithoutQuizAttemptsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountCreateNestedManyWithoutUserInput
|
|
sessions?: SessionCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutQuizAttemptsInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
|
|
sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutUserInput
|
|
certificates?: CertificateUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutQuizAttemptsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutQuizAttemptsInput, UserUncheckedCreateWithoutQuizAttemptsInput>
|
|
}
|
|
|
|
export type QuizCreateWithoutAttemptsInput = {
|
|
id?: string
|
|
passMark?: number
|
|
module: ModuleCreateNestedOneWithoutQuizInput
|
|
questions?: QuestionCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizUncheckedCreateWithoutAttemptsInput = {
|
|
id?: string
|
|
moduleId: string
|
|
passMark?: number
|
|
questions?: QuestionUncheckedCreateNestedManyWithoutQuizInput
|
|
}
|
|
|
|
export type QuizCreateOrConnectWithoutAttemptsInput = {
|
|
where: QuizWhereUniqueInput
|
|
create: XOR<QuizCreateWithoutAttemptsInput, QuizUncheckedCreateWithoutAttemptsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutQuizAttemptsInput = {
|
|
update: XOR<UserUpdateWithoutQuizAttemptsInput, UserUncheckedUpdateWithoutQuizAttemptsInput>
|
|
create: XOR<UserCreateWithoutQuizAttemptsInput, UserUncheckedCreateWithoutQuizAttemptsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutQuizAttemptsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutQuizAttemptsInput, UserUncheckedUpdateWithoutQuizAttemptsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutQuizAttemptsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutQuizAttemptsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutUserNestedInput
|
|
certificates?: CertificateUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type QuizUpsertWithoutAttemptsInput = {
|
|
update: XOR<QuizUpdateWithoutAttemptsInput, QuizUncheckedUpdateWithoutAttemptsInput>
|
|
create: XOR<QuizCreateWithoutAttemptsInput, QuizUncheckedCreateWithoutAttemptsInput>
|
|
where?: QuizWhereInput
|
|
}
|
|
|
|
export type QuizUpdateToOneWithWhereWithoutAttemptsInput = {
|
|
where?: QuizWhereInput
|
|
data: XOR<QuizUpdateWithoutAttemptsInput, QuizUncheckedUpdateWithoutAttemptsInput>
|
|
}
|
|
|
|
export type QuizUpdateWithoutAttemptsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
module?: ModuleUpdateOneRequiredWithoutQuizNestedInput
|
|
questions?: QuestionUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type QuizUncheckedUpdateWithoutAttemptsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
moduleId?: StringFieldUpdateOperationsInput | string
|
|
passMark?: IntFieldUpdateOperationsInput | number
|
|
questions?: QuestionUncheckedUpdateManyWithoutQuizNestedInput
|
|
}
|
|
|
|
export type UserCreateWithoutCertificatesInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountCreateNestedManyWithoutUserInput
|
|
sessions?: SessionCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutCertificatesInput = {
|
|
id?: string
|
|
email: string
|
|
name?: string | null
|
|
image?: string | null
|
|
emailVerified?: Date | string | null
|
|
locale?: string
|
|
role?: $Enums.Role
|
|
createdAt?: Date | string
|
|
accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
|
|
sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutUserInput
|
|
lessonProgress?: LessonProgressUncheckedCreateNestedManyWithoutUserInput
|
|
quizAttempts?: QuizAttemptUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutCertificatesInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutCertificatesInput, UserUncheckedCreateWithoutCertificatesInput>
|
|
}
|
|
|
|
export type CourseCreateWithoutCertificatesInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
modules?: ModuleCreateNestedManyWithoutCourseInput
|
|
enrollments?: EnrollmentCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseUncheckedCreateWithoutCertificatesInput = {
|
|
id?: string
|
|
slug: string
|
|
category?: $Enums.CourseCategory
|
|
level?: $Enums.CourseLevel
|
|
thumbnailUrl?: string | null
|
|
published?: boolean
|
|
order?: number
|
|
createdAt?: Date | string
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
descFr: string
|
|
descEn: string
|
|
descEs: string
|
|
modules?: ModuleUncheckedCreateNestedManyWithoutCourseInput
|
|
enrollments?: EnrollmentUncheckedCreateNestedManyWithoutCourseInput
|
|
}
|
|
|
|
export type CourseCreateOrConnectWithoutCertificatesInput = {
|
|
where: CourseWhereUniqueInput
|
|
create: XOR<CourseCreateWithoutCertificatesInput, CourseUncheckedCreateWithoutCertificatesInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutCertificatesInput = {
|
|
update: XOR<UserUpdateWithoutCertificatesInput, UserUncheckedUpdateWithoutCertificatesInput>
|
|
create: XOR<UserCreateWithoutCertificatesInput, UserUncheckedCreateWithoutCertificatesInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutCertificatesInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutCertificatesInput, UserUncheckedUpdateWithoutCertificatesInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutCertificatesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutCertificatesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
locale?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
|
|
sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutUserNestedInput
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutUserNestedInput
|
|
quizAttempts?: QuizAttemptUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type CourseUpsertWithoutCertificatesInput = {
|
|
update: XOR<CourseUpdateWithoutCertificatesInput, CourseUncheckedUpdateWithoutCertificatesInput>
|
|
create: XOR<CourseCreateWithoutCertificatesInput, CourseUncheckedCreateWithoutCertificatesInput>
|
|
where?: CourseWhereInput
|
|
}
|
|
|
|
export type CourseUpdateToOneWithWhereWithoutCertificatesInput = {
|
|
where?: CourseWhereInput
|
|
data: XOR<CourseUpdateWithoutCertificatesInput, CourseUncheckedUpdateWithoutCertificatesInput>
|
|
}
|
|
|
|
export type CourseUpdateWithoutCertificatesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
modules?: ModuleUpdateManyWithoutCourseNestedInput
|
|
enrollments?: EnrollmentUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type CourseUncheckedUpdateWithoutCertificatesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
category?: EnumCourseCategoryFieldUpdateOperationsInput | $Enums.CourseCategory
|
|
level?: EnumCourseLevelFieldUpdateOperationsInput | $Enums.CourseLevel
|
|
thumbnailUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
published?: BoolFieldUpdateOperationsInput | boolean
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
descFr?: StringFieldUpdateOperationsInput | string
|
|
descEn?: StringFieldUpdateOperationsInput | string
|
|
descEs?: StringFieldUpdateOperationsInput | string
|
|
modules?: ModuleUncheckedUpdateManyWithoutCourseNestedInput
|
|
enrollments?: EnrollmentUncheckedUpdateManyWithoutCourseNestedInput
|
|
}
|
|
|
|
export type AccountCreateManyUserInput = {
|
|
id?: string
|
|
type: string
|
|
provider: string
|
|
providerAccountId: string
|
|
refresh_token?: string | null
|
|
access_token?: string | null
|
|
expires_at?: number | null
|
|
token_type?: string | null
|
|
scope?: string | null
|
|
id_token?: string | null
|
|
session_state?: string | null
|
|
}
|
|
|
|
export type SessionCreateManyUserInput = {
|
|
id?: string
|
|
sessionToken: string
|
|
expires: Date | string
|
|
}
|
|
|
|
export type EnrollmentCreateManyUserInput = {
|
|
id?: string
|
|
courseId: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
}
|
|
|
|
export type LessonProgressCreateManyUserInput = {
|
|
id?: string
|
|
lessonId: string
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type QuizAttemptCreateManyUserInput = {
|
|
id?: string
|
|
quizId: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type CertificateCreateManyUserInput = {
|
|
id?: string
|
|
courseId: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type AccountUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type AccountUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type AccountUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
providerAccountId?: StringFieldUpdateOperationsInput | string
|
|
refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
access_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
expires_at?: NullableIntFieldUpdateOperationsInput | number | null
|
|
token_type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
scope?: NullableStringFieldUpdateOperationsInput | string | null
|
|
id_token?: NullableStringFieldUpdateOperationsInput | string | null
|
|
session_state?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type SessionUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SessionUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SessionUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
sessionToken?: StringFieldUpdateOperationsInput | string
|
|
expires?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type EnrollmentUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
course?: CourseUpdateOneRequiredWithoutEnrollmentsNestedInput
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type LessonProgressUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
lesson?: LessonUpdateOneRequiredWithoutLessonProgressNestedInput
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
lessonId?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
lessonId?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuizAttemptUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
quiz?: QuizUpdateOneRequiredWithoutAttemptsNestedInput
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
quizId?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
quizId?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type CertificateUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
course?: CourseUpdateOneRequiredWithoutCertificatesNestedInput
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
courseId?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type ModuleCreateManyCourseInput = {
|
|
id?: string
|
|
order?: number
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
}
|
|
|
|
export type EnrollmentCreateManyCourseInput = {
|
|
id?: string
|
|
userId: string
|
|
enrolledAt?: Date | string
|
|
completedAt?: Date | string | null
|
|
}
|
|
|
|
export type CertificateCreateManyCourseInput = {
|
|
id?: string
|
|
userId: string
|
|
issuedAt?: Date | string
|
|
pdfUrl?: string | null
|
|
isPaid?: boolean
|
|
}
|
|
|
|
export type ModuleUpdateWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
lessons?: LessonUpdateManyWithoutModuleNestedInput
|
|
quiz?: QuizUpdateOneWithoutModuleNestedInput
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
lessons?: LessonUncheckedUpdateManyWithoutModuleNestedInput
|
|
quiz?: QuizUncheckedUpdateOneWithoutModuleNestedInput
|
|
}
|
|
|
|
export type ModuleUncheckedUpdateManyWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type EnrollmentUpdateWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
user?: UserUpdateOneRequiredWithoutEnrollmentsNestedInput
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type EnrollmentUncheckedUpdateManyWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
enrolledAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
completedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type CertificateUpdateWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
user?: UserUpdateOneRequiredWithoutCertificatesNestedInput
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type CertificateUncheckedUpdateManyWithoutCourseInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
issuedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
pdfUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
isPaid?: BoolFieldUpdateOperationsInput | boolean
|
|
}
|
|
|
|
export type LessonCreateManyModuleInput = {
|
|
id?: string
|
|
order?: number
|
|
type?: $Enums.LessonType
|
|
videoUrl?: string | null
|
|
duration?: number | null
|
|
titleFr: string
|
|
titleEn: string
|
|
titleEs: string
|
|
contentFr?: string | null
|
|
contentEn?: string | null
|
|
contentEs?: string | null
|
|
}
|
|
|
|
export type LessonUpdateWithoutModuleInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
lessonProgress?: LessonProgressUpdateManyWithoutLessonNestedInput
|
|
}
|
|
|
|
export type LessonUncheckedUpdateWithoutModuleInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
lessonProgress?: LessonProgressUncheckedUpdateManyWithoutLessonNestedInput
|
|
}
|
|
|
|
export type LessonUncheckedUpdateManyWithoutModuleInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumLessonTypeFieldUpdateOperationsInput | $Enums.LessonType
|
|
videoUrl?: NullableStringFieldUpdateOperationsInput | string | null
|
|
duration?: NullableIntFieldUpdateOperationsInput | number | null
|
|
titleFr?: StringFieldUpdateOperationsInput | string
|
|
titleEn?: StringFieldUpdateOperationsInput | string
|
|
titleEs?: StringFieldUpdateOperationsInput | string
|
|
contentFr?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEn?: NullableStringFieldUpdateOperationsInput | string | null
|
|
contentEs?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type LessonProgressCreateManyLessonInput = {
|
|
id?: string
|
|
userId: string
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type LessonProgressUpdateWithoutLessonInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutLessonProgressNestedInput
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateWithoutLessonInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type LessonProgressUncheckedUpdateManyWithoutLessonInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuestionCreateManyQuizInput = {
|
|
id?: string
|
|
order?: number
|
|
textFr: string
|
|
textEn: string
|
|
textEs: string
|
|
optionsFr?: QuestionCreateoptionsFrInput | string[]
|
|
optionsEn?: QuestionCreateoptionsEnInput | string[]
|
|
optionsEs?: QuestionCreateoptionsEsInput | string[]
|
|
correctIndex: number
|
|
}
|
|
|
|
export type QuizAttemptCreateManyQuizInput = {
|
|
id?: string
|
|
userId: string
|
|
score: number
|
|
passed: boolean
|
|
answers?: QuizAttemptCreateanswersInput | number[]
|
|
completedAt?: Date | string
|
|
}
|
|
|
|
export type QuestionUpdateWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuestionUncheckedUpdateWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuestionUncheckedUpdateManyWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
order?: IntFieldUpdateOperationsInput | number
|
|
textFr?: StringFieldUpdateOperationsInput | string
|
|
textEn?: StringFieldUpdateOperationsInput | string
|
|
textEs?: StringFieldUpdateOperationsInput | string
|
|
optionsFr?: QuestionUpdateoptionsFrInput | string[]
|
|
optionsEn?: QuestionUpdateoptionsEnInput | string[]
|
|
optionsEs?: QuestionUpdateoptionsEsInput | string[]
|
|
correctIndex?: IntFieldUpdateOperationsInput | number
|
|
}
|
|
|
|
export type QuizAttemptUpdateWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutQuizAttemptsNestedInput
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type QuizAttemptUncheckedUpdateManyWithoutQuizInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
score?: IntFieldUpdateOperationsInput | number
|
|
passed?: BoolFieldUpdateOperationsInput | boolean
|
|
answers?: QuizAttemptUpdateanswersInput | number[]
|
|
completedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Batch Payload for updateMany & deleteMany & createMany
|
|
*/
|
|
|
|
export type BatchPayload = {
|
|
count: number
|
|
}
|
|
|
|
/**
|
|
* DMMF
|
|
*/
|
|
export const dmmf: runtime.BaseDMMF
|
|
} |