& {[prisma]: true}
type UnwrapPromise = P extends Promise ? R : P
type UnwrapTuple = {
[K in keyof Tuple]: K extends `${number}` ? Tuple[K] extends PrismaPromise ? X : UnwrapPromise : UnwrapPromise
};
/**
* Model User
* User model doc
* @@TypeGraphQL.type(name: "MainUser")
*/
export type User = {
/**
* User model field doc
*/
id: number
email: string
/**
* renamed field doc
* @TypeGraphQL.field(name: "firstName")
*/
name: string | null
age: number
/**
* @TypeGraphQL.field(name: "accountBalance")
*/
balance: number
amount: number
role: Role
grades: number[]
aliases: string[]
}
/**
* Model post
*
*/
export type post = {
/**
* first line of comment
* second line of comment
* third line of comment
*/
uuid: string
createdAt: Date
/**
* @TypeGraphQL.omit(input: ["create", "update"])
*/
updatedAt: Date
/**
* @TypeGraphQL.omit(input: true)
*/
published: boolean
title: string
/**
* @TypeGraphQL.omit(output: true)
*/
subtitle: string
content: string | null
authorId: number
/**
* @TypeGraphQL.omit(output: true)
*/
editorId: number | null
kind: PostKind | null
metadata: Prisma.JsonValue
}
/**
* Model Category
*
*/
export type Category = {
name: string
slug: string
number: number
}
/**
* Model Patient
*
*/
export type Patient = {
firstName: string
lastName: string
email: string
}
/**
* Model Movie
*
*/
export type Movie = {
directorFirstName: string
directorLastName: string
title: string
}
/**
* Model Director
*
*/
export type Director = {
firstName: string
lastName: string
}
/**
* Model Problem
*
*/
export type Problem = {
id: number
problemText: string
creatorId: number | null
}
/**
* Model Creator
*
*/
export type Creator = {
id: number
name: string
}
/**
* Model NativeTypeModel
*
*/
export type NativeTypeModel = {
id: number
bigInt: bigint | null
byteA: Buffer | null
decimal: Prisma.Decimal | null
}
/**
* Model Equipment
* @@TypeGraphQL.type(plural: "equipments")
*/
export type Equipment = {
id: string
}
/**
* Enums
*/
// Based on
// https://github.com/microsoft/TypeScript/issues/3192#issuecomment-261720275
export const PostKind: {
BLOG: 'BLOG',
ADVERT: 'ADVERT'
};
export type PostKind = (typeof PostKind)[keyof typeof PostKind]
export const Role: {
USER: 'USER',
ADMIN: 'ADMIN'
};
export type Role = (typeof Role)[keyof typeof Role]
/**
* ## 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<
T extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
U = 'log' extends keyof T ? T['log'] extends Array ? Prisma.GetEvents : never : never,
GlobalReject extends Prisma.RejectOnNotFound | Prisma.RejectPerOperation | false | undefined = 'rejectOnNotFound' extends keyof T
? T['rejectOnNotFound']
: false,
ExtArgs extends runtime.Types.Extensions.Args = runtime.Types.Extensions.DefaultArgs
> {
/**
* ## 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);
$on(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => Promise : Prisma.LogEvent) => void): void;
/**
* Connect with the database
*/
$connect(): Promise;
/**
* Disconnect from the database
*/
$disconnect(): Promise;
/**
* Add a middleware
*/
$use(cb: Prisma.Middleware): void
/**
* Executes a prepared raw query and returns the number of affected rows.
* @example
* ```
* const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): PrismaPromise;
/**
* Executes a raw query and returns the number of affected rows.
* Susceptible to SQL injections, see documentation.
* @example
* ```
* const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$executeRawUnsafe(query: string, ...values: any[]): PrismaPromise;
/**
* Performs a prepared raw query and returns the `SELECT` data.
* @example
* ```
* const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$queryRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): PrismaPromise;
/**
* Performs a raw query and returns the `SELECT` data.
* Susceptible to SQL injections, see documentation.
* @example
* ```
* const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$queryRawUnsafe(query: string, ...values: any[]): PrismaPromise;
/**
* Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
* @example
* ```
* const [george, bob, alice] = await prisma.$transaction([
* prisma.user.create({ data: { name: 'George' } }),
* prisma.user.create({ data: { name: 'Bob' } }),
* prisma.user.create({ data: { name: 'Alice' } }),
* ])
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
*/
$transaction[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): Promise>;
$transaction(fn: (prisma: Prisma.TransactionClient) => Promise, options?: {maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel}): Promise;
$extends: { extArgs: ExtArgs } & (<
R_User_Needs extends Record>,
R_post_Needs extends Record>,
R_Category_Needs extends Record>,
R_Patient_Needs extends Record>,
R_Movie_Needs extends Record>,
R_Director_Needs extends Record>,
R_Problem_Needs extends Record>,
R_Creator_Needs extends Record>,
R_NativeTypeModel_Needs extends Record>,
R_Equipment_Needs extends Record>,
R extends runtime.Types.Extensions.Args['result'] = {},
M extends runtime.Types.Extensions.Args['model'] = {},
Q extends runtime.Types.Extensions.Args['query'] = {},
C extends runtime.Types.Extensions.Args['client'] = {},
Args extends runtime.Types.Extensions.Args = { result: R, model: M, query: Q, client: C },
>(extension: ((client: this) => { $extends: { extArgs: Args } }) | Prisma.ExtensionArgs<
ExtArgs,
R_User_Needs,
R_post_Needs,
R_Category_Needs,
R_Patient_Needs,
R_Movie_Needs,
R_Director_Needs,
R_Problem_Needs,
R_Creator_Needs,
R_NativeTypeModel_Needs,
R_Equipment_Needs,
R,
M,
Q,
C
>) => runtime.Types.Extensions.GetClient, Args['client'], ExtArgs['client']>);
/**
* `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(): runtime.Types.Extensions.GetModel, ExtArgs['model']['user']>;
/**
* `prisma.post`: Exposes CRUD operations for the **post** model.
* Example usage:
* ```ts
* // Fetch zero or more Posts
* const posts = await prisma.post.findMany()
* ```
*/
get post(): runtime.Types.Extensions.GetModel, ExtArgs['model']['post']>;
/**
* `prisma.category`: Exposes CRUD operations for the **Category** model.
* Example usage:
* ```ts
* // Fetch zero or more Categories
* const categories = await prisma.category.findMany()
* ```
*/
get category(): runtime.Types.Extensions.GetModel, ExtArgs['model']['category']>;
/**
* `prisma.patient`: Exposes CRUD operations for the **Patient** model.
* Example usage:
* ```ts
* // Fetch zero or more Patients
* const patients = await prisma.patient.findMany()
* ```
*/
get patient(): runtime.Types.Extensions.GetModel, ExtArgs['model']['patient']>;
/**
* `prisma.movie`: Exposes CRUD operations for the **Movie** model.
* Example usage:
* ```ts
* // Fetch zero or more Movies
* const movies = await prisma.movie.findMany()
* ```
*/
get movie(): runtime.Types.Extensions.GetModel, ExtArgs['model']['movie']>;
/**
* `prisma.director`: Exposes CRUD operations for the **Director** model.
* Example usage:
* ```ts
* // Fetch zero or more Directors
* const directors = await prisma.director.findMany()
* ```
*/
get director(): runtime.Types.Extensions.GetModel, ExtArgs['model']['director']>;
/**
* `prisma.problem`: Exposes CRUD operations for the **Problem** model.
* Example usage:
* ```ts
* // Fetch zero or more Problems
* const problems = await prisma.problem.findMany()
* ```
*/
get problem(): runtime.Types.Extensions.GetModel, ExtArgs['model']['problem']>;
/**
* `prisma.creator`: Exposes CRUD operations for the **Creator** model.
* Example usage:
* ```ts
* // Fetch zero or more Creators
* const creators = await prisma.creator.findMany()
* ```
*/
get creator(): runtime.Types.Extensions.GetModel, ExtArgs['model']['creator']>;
/**
* `prisma.nativeTypeModel`: Exposes CRUD operations for the **NativeTypeModel** model.
* Example usage:
* ```ts
* // Fetch zero or more NativeTypeModels
* const nativeTypeModels = await prisma.nativeTypeModel.findMany()
* ```
*/
get nativeTypeModel(): runtime.Types.Extensions.GetModel, ExtArgs['model']['nativeTypeModel']>;
/**
* `prisma.equipment`: Exposes CRUD operations for the **Equipment** model.
* Example usage:
* ```ts
* // Fetch zero or more Equipment
* const equipment = await prisma.equipment.findMany()
* ```
*/
get equipment(): runtime.Types.Extensions.GetModel, ExtArgs['model']['equipment']>;
}
export namespace Prisma {
export import DMMF = runtime.DMMF
/**
* 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
export import NotFoundError = runtime.NotFoundError
/**
* Re-export of sql-template-tag
*/
export import sql = runtime.sqltag
export import empty = runtime.empty
export import join = runtime.join
export import raw = runtime.raw
export import Sql = runtime.Sql
/**
* Decimal.js
*/
export import Decimal = runtime.Decimal
export type DecimalJsLike = runtime.DecimalJsLike
/**
* Metrics
*/
export type Metrics = runtime.Metrics
export type Metric = runtime.Metric
export type MetricHistogram = runtime.MetricHistogram
export type MetricHistogramBucket = runtime.MetricHistogramBucket
/**
* Extensions
*/
export type Extension = runtime.Types.Extensions.Args
export import getExtensionContext = runtime.Extensions.getExtensionContext
/**
* Prisma Client JS version: 4.8.0
* Query Engine version: d6e67a83f971b175a593ccc12e15c4a757f93ffe
*/
export type PrismaVersion = {
client: string
}
export const prismaVersion: PrismaVersion
/**
* Utility Types
*/
/**
* From https://github.com/sindresorhus/type-fest/
* Matches a JSON object.
* This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from.
*/
export type JsonObject = {[Key in string]?: JsonValue}
/**
* From https://github.com/sindresorhus/type-fest/
* Matches a JSON array.
*/
export interface JsonArray extends Array {}
/**
* From https://github.com/sindresorhus/type-fest/
* Matches any valid JSON value.
*/
export type JsonValue = string | number | boolean | JsonObject | JsonArray | null
/**
* Matches a JSON object.
* Unlike `JsonObject`, this type allows undefined and read-only properties.
*/
export type InputJsonObject = {readonly [Key in string]?: InputJsonValue | null}
/**
* Matches a JSON array.
* Unlike `JsonArray`, readonly arrays are assignable to this type.
*/
export interface InputJsonArray extends ReadonlyArray {}
/**
* Matches any valid value that can be used as an input for operations like
* create and update as the value of a JSON field. Unlike `JsonValue`, this
* type allows read-only arrays and read-only object properties and disallows
* `null` at the top level.
*
* `null` cannot be used as the value of a JSON field because its meaning
* would be ambiguous. Use `Prisma.JsonNull` to store the JSON null value or
* `Prisma.DbNull` to clear the JSON value and set the field to the database
* NULL value instead.
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
*/
export type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray
/**
* 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 HasSelect = {
select: any
}
type HasInclude = {
include: any
}
type CheckSelect = T extends SelectAndInclude
? 'Please either choose `select` or `include`'
: T extends HasSelect
? U
: T extends HasInclude
? U
: S
/**
* Get the type of the value, that the Promise holds.
*/
export type PromiseType> = T extends PromiseLike ? U : T;
/**
* Get the return type of a function which returns a Promise.
*/
export type PromiseReturnType Promise> = PromiseType>
/**
* From T, pick a set of properties whose keys are in the union K
*/
type Prisma__Pick = {
[P in K]: T[P];
};
export type Enumerable = T | Array;
export type RequiredKeys = {
[K in keyof T]-?: {} extends Prisma__Pick ? never : K
}[keyof T]
export type TruthyKeys = keyof {
[K in keyof T as T[K] extends false | undefined | null ? never : K]: K
}
export type TrueKeys = TruthyKeys>>
/**
* Subset
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection
*/
export type Subset = {
[key in keyof T]: key extends keyof U ? T[key] : never;
};
/**
* SelectSubset
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
* Additionally, it validates, if both select and include are present. If the case, it errors.
*/
export type SelectSubset = {
[key in keyof T]: key extends keyof U ? T[key] : never
} &
(T extends SelectAndInclude
? 'Please either choose `select` or `include`.'
: {})
/**
* Subset + Intersection
* @desc From `T` pick properties that exist in `U` and intersect `K`
*/
export type SubsetIntersection = {
[key in keyof T]: key extends keyof U ? T[key] : never
} &
K
type Without = { [P in Exclude]?: never };
/**
* XOR is needed to have a real mutually exclusive union type
* https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
*/
type XOR =
T extends object ?
U extends object ?
(Without & U) | (Without & T)
: U : T
/**
* Is T a Record?
*/
type IsObject = T extends Array
? False
: T extends Date
? False
: T extends Uint8Array
? False
: T extends BigInt
? False
: T extends object
? True
: False
/**
* If it's T[], return T
*/
export type UnEnumerate = T extends Array ? U : T
/**
* From ts-toolbelt
*/
type __Either = Omit &
{
// Merge all but K
[P in K]: Prisma__Pick // With K possibilities
}[K]
type EitherStrict = Strict<__Either>
type EitherLoose = ComputeRaw<__Either>
type _Either<
O extends object,
K extends Key,
strict extends Boolean
> = {
1: EitherStrict
0: EitherLoose
}[strict]
type Either<
O extends object,
K extends Key,
strict extends Boolean = 1
> = O extends unknown ? _Either : never
export type Union = any
type PatchUndefined = {
[K in keyof O]: O[K] extends undefined ? At : O[K]
} & {}
/** Helper Types for "Merge" **/
export type IntersectOf = (
U extends unknown ? (k: U) => void : never
) extends (k: infer I) => void
? I
: never
export type Overwrite = {
[K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
} & {};
type _Merge = IntersectOf;
}>>;
type Key = string | number | symbol;
type AtBasic = K extends keyof O ? O[K] : never;
type AtStrict = O[K & keyof O];
type AtLoose = O extends unknown ? AtStrict : never;
export type At = {
1: AtStrict;
0: AtLoose;
}[strict];
export type ComputeRaw = A extends Function ? A : {
[K in keyof A]: A[K];
} & {};
export type OptionalFlat = {
[K in keyof O]?: O[K];
} & {};
type _Record = {
[P in K]: T;
};
// cause typescript not to expand types and preserve names
type NoExpand = T extends unknown ? T : never;
// this type assumes the passed object is entirely optional
type AtLeast = NoExpand<
O extends unknown
? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
| {[P in keyof O as P extends K ? K : never]-?: O[P]} & O
: never>;
type _Strict = U extends unknown ? U & OptionalFlat<_Record, keyof U>, never>> : never;
export type Strict = ComputeRaw<_Strict>;
/** End Helper Types for "Merge" **/
export type Merge = ComputeRaw<_Merge>>;
/**
A [[Boolean]]
*/
export type Boolean = True | False
// /**
// 1
// */
export type True = 1
/**
0
*/
export type False = 0
export type Not = {
0: 1
1: 0
}[B]
export type Extends = [A1] extends [never]
? 0 // anything `never` is false
: A1 extends A2
? 1
: 0
export type Has = Not<
Extends, U1>
>
export type Or = {
0: {
0: 0
1: 1
}
1: {
0: 1
1: 1
}
}[B1][B2]
export type Keys = U extends unknown ? keyof U : never
type Exact =
W extends unknown ? A extends Narrowable ? Cast : Cast<
{[K in keyof A]: K extends keyof W ? Exact : never},
{[K in keyof W]: K extends keyof A ? Exact : W[K]}>
: never;
type Narrowable = string | number | boolean | bigint;
type Cast = A extends B ? A : B;
export const type: unique symbol;
export function validator(): (select: Exact) => S;
/**
* Used by group by
*/
export type GetScalarType = O extends object ? {
[P in keyof T]: P extends keyof O
? O[P]
: never
} : never
type FieldPaths<
T,
U = Omit
> = IsObject extends True ? U : T
type GetHavingFields = {
[K in keyof T]: Or<
Or, Extends<'AND', K>>,
Extends<'NOT', K>
> extends True
? // infer is only needed to not hit TS limit
// based on the brilliant idea of Pierre-Antoine Mills
// https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
T[K] extends infer TK
? GetHavingFields extends object ? Merge> : never>
: never
: {} extends FieldPaths
? never
: K
}[keyof T]
/**
* Convert tuple to union
*/
type _TupleToUnion = T extends (infer E)[] ? E : never
type TupleToUnion = _TupleToUnion
type MaybeTupleToUnion = T extends any[] ? TupleToUnion : T
/**
* Like `Pick`, but with an array
*/
type PickArray> = Prisma__Pick>
/**
* Exclude all keys with underscores
*/
type ExcludeUnderscoreKeys = T extends `_${string}` ? never : T
export type FieldRef = runtime.FieldRef
type FieldRefInputType = Model extends never ? never : FieldRef
class PrismaClientFetcher {
private readonly prisma;
private readonly debug;
private readonly hooks?;
constructor(prisma: PrismaClient, debug?: boolean, hooks?: Hooks | undefined);
request(document: any, dataPath?: string[], rootField?: string, typeName?: string, isList?: boolean, callsite?: string): Promise;
sanitizeMessage(message: string): string;
protected unpack(document: any, data: any, path: string[], rootField?: string, isList?: boolean): any;
}
export const ModelName: {
User: 'User',
post: 'post',
Category: 'Category',
Patient: 'Patient',
Movie: 'Movie',
Director: 'Director',
Problem: 'Problem',
Creator: 'Creator',
NativeTypeModel: 'NativeTypeModel',
Equipment: 'Equipment'
};
export type ModelName = (typeof ModelName)[keyof typeof ModelName]
export type Datasources = {
postgres?: Datasource
}
export function defineExtension<
R_User_Needs extends Record>,
R_post_Needs extends Record>,
R_Category_Needs extends Record>,
R_Patient_Needs extends Record>,
R_Movie_Needs extends Record>,
R_Director_Needs extends Record>,
R_Problem_Needs extends Record>,
R_Creator_Needs extends Record>,
R_NativeTypeModel_Needs extends Record>,
R_Equipment_Needs extends Record>,
R extends runtime.Types.Extensions.Args['result'] = {},
M extends runtime.Types.Extensions.Args['model'] = {},
Q extends runtime.Types.Extensions.Args['query'] = {},
C extends runtime.Types.Extensions.Args['client'] = {},
Args extends runtime.Types.Extensions.Args = { result: R, model: M, query: Q, client: C },
ExtArgs extends runtime.Types.Extensions.Args = runtime.Types.Extensions.DefaultArgs,
>(extension: ((client: Prisma.DefaultPrismaClient) => { $extends: { extArgs: Args } }) | Prisma.ExtensionArgs<
ExtArgs,
R_User_Needs,
R_post_Needs,
R_Category_Needs,
R_Patient_Needs,
R_Movie_Needs,
R_Director_Needs,
R_Problem_Needs,
R_Creator_Needs,
R_NativeTypeModel_Needs,
R_Equipment_Needs,
R,
M,
Q,
C
>) : (client: any) => PrismaClient;
export type TypeMap = {
model: {
User: {
findUnique: {
args: Prisma.UserFindUniqueArgs,
result: runtime.Types.Utils.OptionalFlat
}
findUniqueOrThrow: {
args: Prisma.UserFindUniqueOrThrowArgs,
result: runtime.Types.Utils.OptionalFlat
}
findFirst: {
args: Prisma.UserFindFirstArgs,
result: runtime.Types.Utils.OptionalFlat
}
findFirstOrThrow: {
args: Prisma.UserFindFirstOrThrowArgs,
result: runtime.Types.Utils.OptionalFlat
}
findMany: {
args: Prisma.UserFindManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
create: {
args: Prisma.UserCreateArgs,
result: runtime.Types.Utils.OptionalFlat
}
createMany: {
args: Prisma.UserCreateManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
delete: {
args: Prisma.UserDeleteArgs,
result: runtime.Types.Utils.OptionalFlat
}
update: {
args: Prisma.UserUpdateArgs,
result: runtime.Types.Utils.OptionalFlat
}
deleteMany: {
args: Prisma.UserDeleteManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
updateMany: {
args: Prisma.UserUpdateManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
upsert: {
args: Prisma.UserUpsertArgs,
result: runtime.Types.Utils.OptionalFlat
}
aggregate: {
args: Prisma.UserAggregateArgs,
result: runtime.Types.Utils.OptionalFlat
}
groupBy: {
args: Prisma.UserGroupByArgs,
result: runtime.Types.Utils.OptionalFlat
}
count: {
args: Prisma.UserCountArgs,
result: runtime.Types.Utils.OptionalFlat
}
}
post: {
findUnique: {
args: Prisma.postFindUniqueArgs,
result: runtime.Types.Utils.OptionalFlat
}
findUniqueOrThrow: {
args: Prisma.postFindUniqueOrThrowArgs,
result: runtime.Types.Utils.OptionalFlat
}
findFirst: {
args: Prisma.postFindFirstArgs,
result: runtime.Types.Utils.OptionalFlat
}
findFirstOrThrow: {
args: Prisma.postFindFirstOrThrowArgs,
result: runtime.Types.Utils.OptionalFlat
}
findMany: {
args: Prisma.postFindManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
create: {
args: Prisma.postCreateArgs,
result: runtime.Types.Utils.OptionalFlat
}
createMany: {
args: Prisma.postCreateManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
delete: {
args: Prisma.postDeleteArgs,
result: runtime.Types.Utils.OptionalFlat
}
update: {
args: Prisma.postUpdateArgs,
result: runtime.Types.Utils.OptionalFlat
}
deleteMany: {
args: Prisma.postDeleteManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
updateMany: {
args: Prisma.postUpdateManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
upsert: {
args: Prisma.postUpsertArgs,
result: runtime.Types.Utils.OptionalFlat
}
aggregate: {
args: Prisma.PostAggregateArgs,
result: runtime.Types.Utils.OptionalFlat
}
groupBy: {
args: Prisma.postGroupByArgs,
result: runtime.Types.Utils.OptionalFlat
}
count: {
args: Prisma.postCountArgs,
result: runtime.Types.Utils.OptionalFlat
}
}
Category: {
findUnique: {
args: Prisma.CategoryFindUniqueArgs,
result: runtime.Types.Utils.OptionalFlat
}
findUniqueOrThrow: {
args: Prisma.CategoryFindUniqueOrThrowArgs,
result: runtime.Types.Utils.OptionalFlat
}
findFirst: {
args: Prisma.CategoryFindFirstArgs,
result: runtime.Types.Utils.OptionalFlat
}
findFirstOrThrow: {
args: Prisma.CategoryFindFirstOrThrowArgs,
result: runtime.Types.Utils.OptionalFlat
}
findMany: {
args: Prisma.CategoryFindManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
create: {
args: Prisma.CategoryCreateArgs,
result: runtime.Types.Utils.OptionalFlat
}
createMany: {
args: Prisma.CategoryCreateManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
delete: {
args: Prisma.CategoryDeleteArgs,
result: runtime.Types.Utils.OptionalFlat
}
update: {
args: Prisma.CategoryUpdateArgs,
result: runtime.Types.Utils.OptionalFlat
}
deleteMany: {
args: Prisma.CategoryDeleteManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
updateMany: {
args: Prisma.CategoryUpdateManyArgs,
result: runtime.Types.Utils.OptionalFlat
}
upsert: {
args: Prisma.CategoryUpsertArgs,
result: runtime.Types.Utils.OptionalFlat
}
aggregate: {
args: Prisma.CategoryAggregateArgs,
result: runtime.Types.Utils.OptionalFlat
}
groupBy: {
args: Prisma.CategoryGroupByArgs,
result: runtime.Types.Utils.OptionalFlat
}
count: {
args: Prisma.CategoryCountArgs,
result: runtime.Types.Utils.OptionalFlat
}
}
Patient: {
findUnique: {
args: Prisma.PatientFindUniqueArgs,
result: runtime.Types.Utils.OptionalFlat
}
findUniqueOrThrow: {
args: Prisma.PatientFindUniqueOrThrowArgs