zemenay-blog
Version:
Zemenay Blog as a pluggable Next.js package (dedicated DB)
1,490 lines (1,365 loc) • 767 kB
TypeScript
/**
* Client
**/
import * as runtime from './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 Role
*
*/
export type Role = $Result.DefaultSelection<Prisma.$RolePayload>
/**
* Model User
*
*/
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
* Model Post
*
*/
export type Post = $Result.DefaultSelection<Prisma.$PostPayload>
/**
* Model PostImage
*
*/
export type PostImage = $Result.DefaultSelection<Prisma.$PostImagePayload>
/**
* Model Category
*
*/
export type Category = $Result.DefaultSelection<Prisma.$CategoryPayload>
/**
* Model Tag
*
*/
export type Tag = $Result.DefaultSelection<Prisma.$TagPayload>
/**
* Model PostTag
*
*/
export type PostTag = $Result.DefaultSelection<Prisma.$PostTagPayload>
/**
* Model Like
*
*/
export type Like = $Result.DefaultSelection<Prisma.$LikePayload>
/**
* Model Comment
*
*/
export type Comment = $Result.DefaultSelection<Prisma.$CommentPayload>
/**
* Model PostAnalytic
*
*/
export type PostAnalytic = $Result.DefaultSelection<Prisma.$PostAnalyticPayload>
/**
* Model AdminAuditLog
*
*/
export type AdminAuditLog = $Result.DefaultSelection<Prisma.$AdminAuditLogPayload>
/**
* Enums
*/
export namespace $Enums {
export const PostStatus: {
draft: 'draft',
published: 'published',
archived: 'archived'
};
export type PostStatus = (typeof PostStatus)[keyof typeof PostStatus]
}
export type PostStatus = $Enums.PostStatus
export const PostStatus: typeof $Enums.PostStatus
/**
* ## Prisma Client ʲˢ
*
* Type-safe database client for TypeScript & Node.js
* @example
* ```
* const prisma = new PrismaClient()
* // Fetch zero or more Roles
* const roles = await prisma.role.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 Roles
* const roles = await prisma.role.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.role`: Exposes CRUD operations for the **Role** model.
* Example usage:
* ```ts
* // Fetch zero or more Roles
* const roles = await prisma.role.findMany()
* ```
*/
get role(): Prisma.RoleDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.user`: Exposes CRUD operations for the **User** model.
* Example usage:
* ```ts
* // Fetch zero or more Users
* const users = await prisma.user.findMany()
* ```
*/
get user(): Prisma.UserDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.post`: Exposes CRUD operations for the **Post** model.
* Example usage:
* ```ts
* // Fetch zero or more Posts
* const posts = await prisma.post.findMany()
* ```
*/
get post(): Prisma.PostDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.postImage`: Exposes CRUD operations for the **PostImage** model.
* Example usage:
* ```ts
* // Fetch zero or more PostImages
* const postImages = await prisma.postImage.findMany()
* ```
*/
get postImage(): Prisma.PostImageDelegate<ExtArgs, ClientOptions>;
/**
* `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(): Prisma.CategoryDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.tag`: Exposes CRUD operations for the **Tag** model.
* Example usage:
* ```ts
* // Fetch zero or more Tags
* const tags = await prisma.tag.findMany()
* ```
*/
get tag(): Prisma.TagDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.postTag`: Exposes CRUD operations for the **PostTag** model.
* Example usage:
* ```ts
* // Fetch zero or more PostTags
* const postTags = await prisma.postTag.findMany()
* ```
*/
get postTag(): Prisma.PostTagDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.like`: Exposes CRUD operations for the **Like** model.
* Example usage:
* ```ts
* // Fetch zero or more Likes
* const likes = await prisma.like.findMany()
* ```
*/
get like(): Prisma.LikeDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.comment`: Exposes CRUD operations for the **Comment** model.
* Example usage:
* ```ts
* // Fetch zero or more Comments
* const comments = await prisma.comment.findMany()
* ```
*/
get comment(): Prisma.CommentDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.postAnalytic`: Exposes CRUD operations for the **PostAnalytic** model.
* Example usage:
* ```ts
* // Fetch zero or more PostAnalytics
* const postAnalytics = await prisma.postAnalytic.findMany()
* ```
*/
get postAnalytic(): Prisma.PostAnalyticDelegate<ExtArgs, ClientOptions>;
/**
* `prisma.adminAuditLog`: Exposes CRUD operations for the **AdminAuditLog** model.
* Example usage:
* ```ts
* // Fetch zero or more AdminAuditLogs
* const adminAuditLogs = await prisma.adminAuditLog.findMany()
* ```
*/
get adminAuditLog(): Prisma.AdminAuditLogDelegate<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.14.0
* Query Engine version: 717184b7b35ea05dfa71a3236b7af656013e1e49
*/
export type PrismaVersion = {
client: string
}
export const prismaVersion: PrismaVersion
/**
* Utility Types
*/
export import JsonObject = runtime.JsonObject
export import JsonArray = runtime.JsonArray
export import JsonValue = runtime.JsonValue
export import InputJsonObject = runtime.InputJsonObject
export import InputJsonArray = runtime.InputJsonArray
export import InputJsonValue = runtime.InputJsonValue
/**
* Types of the values used to represent different kinds of `null` values when working with JSON fields.
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
namespace NullTypes {
/**
* Type of `Prisma.DbNull`.
*
* You cannot use other instances of this class. Please use the `Prisma.DbNull` value.
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
class DbNull {
private DbNull: never
private constructor()
}
/**
* Type of `Prisma.JsonNull`.
*
* You cannot use other instances of this class. Please use the `Prisma.JsonNull` value.
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
class JsonNull {
private JsonNull: never
private constructor()
}
/**
* Type of `Prisma.AnyNull`.
*
* You cannot use other instances of this class. Please use the `Prisma.AnyNull` value.
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
class AnyNull {
private AnyNull: never
private constructor()
}
}
/**
* Helper for filtering JSON entries that have `null` on the database (empty on the db)
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
export const DbNull: NullTypes.DbNull
/**
* Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
export const JsonNull: NullTypes.JsonNull
/**
* Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
export const AnyNull: NullTypes.AnyNull
type SelectAndInclude = {
select: any
include: any
}
type SelectAndOmit = {
select: any
omit: any
}
/**
* Get the type of the value, that the Promise holds.
*/
export type PromiseType<T extends PromiseLike<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: {
Role: 'Role',
User: 'User',
Post: 'Post',
PostImage: 'PostImage',
Category: 'Category',
Tag: 'Tag',
PostTag: 'PostTag',
Like: 'Like',
Comment: 'Comment',
PostAnalytic: 'PostAnalytic',
AdminAuditLog: 'AdminAuditLog'
};
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: "role" | "user" | "post" | "postImage" | "category" | "tag" | "postTag" | "like" | "comment" | "postAnalytic" | "adminAuditLog"
txIsolationLevel: Prisma.TransactionIsolationLevel
}
model: {
Role: {
payload: Prisma.$RolePayload<ExtArgs>
fields: Prisma.RoleFieldRefs
operations: {
findUnique: {
args: Prisma.RoleFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload> | null
}
findUniqueOrThrow: {
args: Prisma.RoleFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>
}
findFirst: {
args: Prisma.RoleFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload> | null
}
findFirstOrThrow: {
args: Prisma.RoleFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>
}
findMany: {
args: Prisma.RoleFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>[]
}
create: {
args: Prisma.RoleCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>
}
createMany: {
args: Prisma.RoleCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.RoleCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>[]
}
delete: {
args: Prisma.RoleDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>
}
update: {
args: Prisma.RoleUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>
}
deleteMany: {
args: Prisma.RoleDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.RoleUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.RoleUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>[]
}
upsert: {
args: Prisma.RoleUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$RolePayload>
}
aggregate: {
args: Prisma.RoleAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregateRole>
}
groupBy: {
args: Prisma.RoleGroupByArgs<ExtArgs>
result: $Utils.Optional<RoleGroupByOutputType>[]
}
count: {
args: Prisma.RoleCountArgs<ExtArgs>
result: $Utils.Optional<RoleCountAggregateOutputType> | number
}
}
}
User: {
payload: Prisma.$UserPayload<ExtArgs>
fields: Prisma.UserFieldRefs
operations: {
findUnique: {
args: Prisma.UserFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
}
findUniqueOrThrow: {
args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>
}
findFirst: {
args: Prisma.UserFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
}
findFirstOrThrow: {
args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>
}
findMany: {
args: Prisma.UserFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
}
create: {
args: Prisma.UserCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>
}
createMany: {
args: Prisma.UserCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
}
delete: {
args: Prisma.UserDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>
}
update: {
args: Prisma.UserUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>
}
deleteMany: {
args: Prisma.UserDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.UserUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
}
upsert: {
args: Prisma.UserUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$UserPayload>
}
aggregate: {
args: Prisma.UserAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregateUser>
}
groupBy: {
args: Prisma.UserGroupByArgs<ExtArgs>
result: $Utils.Optional<UserGroupByOutputType>[]
}
count: {
args: Prisma.UserCountArgs<ExtArgs>
result: $Utils.Optional<UserCountAggregateOutputType> | number
}
}
}
Post: {
payload: Prisma.$PostPayload<ExtArgs>
fields: Prisma.PostFieldRefs
operations: {
findUnique: {
args: Prisma.PostFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload> | null
}
findUniqueOrThrow: {
args: Prisma.PostFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>
}
findFirst: {
args: Prisma.PostFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload> | null
}
findFirstOrThrow: {
args: Prisma.PostFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>
}
findMany: {
args: Prisma.PostFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>[]
}
create: {
args: Prisma.PostCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>
}
createMany: {
args: Prisma.PostCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.PostCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>[]
}
delete: {
args: Prisma.PostDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>
}
update: {
args: Prisma.PostUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>
}
deleteMany: {
args: Prisma.PostDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.PostUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.PostUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>[]
}
upsert: {
args: Prisma.PostUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostPayload>
}
aggregate: {
args: Prisma.PostAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregatePost>
}
groupBy: {
args: Prisma.PostGroupByArgs<ExtArgs>
result: $Utils.Optional<PostGroupByOutputType>[]
}
count: {
args: Prisma.PostCountArgs<ExtArgs>
result: $Utils.Optional<PostCountAggregateOutputType> | number
}
}
}
PostImage: {
payload: Prisma.$PostImagePayload<ExtArgs>
fields: Prisma.PostImageFieldRefs
operations: {
findUnique: {
args: Prisma.PostImageFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload> | null
}
findUniqueOrThrow: {
args: Prisma.PostImageFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>
}
findFirst: {
args: Prisma.PostImageFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload> | null
}
findFirstOrThrow: {
args: Prisma.PostImageFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>
}
findMany: {
args: Prisma.PostImageFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>[]
}
create: {
args: Prisma.PostImageCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>
}
createMany: {
args: Prisma.PostImageCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.PostImageCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>[]
}
delete: {
args: Prisma.PostImageDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>
}
update: {
args: Prisma.PostImageUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>
}
deleteMany: {
args: Prisma.PostImageDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.PostImageUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.PostImageUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>[]
}
upsert: {
args: Prisma.PostImageUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostImagePayload>
}
aggregate: {
args: Prisma.PostImageAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregatePostImage>
}
groupBy: {
args: Prisma.PostImageGroupByArgs<ExtArgs>
result: $Utils.Optional<PostImageGroupByOutputType>[]
}
count: {
args: Prisma.PostImageCountArgs<ExtArgs>
result: $Utils.Optional<PostImageCountAggregateOutputType> | number
}
}
}
Category: {
payload: Prisma.$CategoryPayload<ExtArgs>
fields: Prisma.CategoryFieldRefs
operations: {
findUnique: {
args: Prisma.CategoryFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload> | null
}
findUniqueOrThrow: {
args: Prisma.CategoryFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
}
findFirst: {
args: Prisma.CategoryFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload> | null
}
findFirstOrThrow: {
args: Prisma.CategoryFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
}
findMany: {
args: Prisma.CategoryFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>[]
}
create: {
args: Prisma.CategoryCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
}
createMany: {
args: Prisma.CategoryCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.CategoryCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>[]
}
delete: {
args: Prisma.CategoryDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
}
update: {
args: Prisma.CategoryUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
}
deleteMany: {
args: Prisma.CategoryDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.CategoryUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.CategoryUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>[]
}
upsert: {
args: Prisma.CategoryUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
}
aggregate: {
args: Prisma.CategoryAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregateCategory>
}
groupBy: {
args: Prisma.CategoryGroupByArgs<ExtArgs>
result: $Utils.Optional<CategoryGroupByOutputType>[]
}
count: {
args: Prisma.CategoryCountArgs<ExtArgs>
result: $Utils.Optional<CategoryCountAggregateOutputType> | number
}
}
}
Tag: {
payload: Prisma.$TagPayload<ExtArgs>
fields: Prisma.TagFieldRefs
operations: {
findUnique: {
args: Prisma.TagFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload> | null
}
findUniqueOrThrow: {
args: Prisma.TagFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>
}
findFirst: {
args: Prisma.TagFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload> | null
}
findFirstOrThrow: {
args: Prisma.TagFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>
}
findMany: {
args: Prisma.TagFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
}
create: {
args: Prisma.TagCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>
}
createMany: {
args: Prisma.TagCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.TagCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
}
delete: {
args: Prisma.TagDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>
}
update: {
args: Prisma.TagUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>
}
deleteMany: {
args: Prisma.TagDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.TagUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.TagUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
}
upsert: {
args: Prisma.TagUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$TagPayload>
}
aggregate: {
args: Prisma.TagAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregateTag>
}
groupBy: {
args: Prisma.TagGroupByArgs<ExtArgs>
result: $Utils.Optional<TagGroupByOutputType>[]
}
count: {
args: Prisma.TagCountArgs<ExtArgs>
result: $Utils.Optional<TagCountAggregateOutputType> | number
}
}
}
PostTag: {
payload: Prisma.$PostTagPayload<ExtArgs>
fields: Prisma.PostTagFieldRefs
operations: {
findUnique: {
args: Prisma.PostTagFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload> | null
}
findUniqueOrThrow: {
args: Prisma.PostTagFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>
}
findFirst: {
args: Prisma.PostTagFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload> | null
}
findFirstOrThrow: {
args: Prisma.PostTagFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>
}
findMany: {
args: Prisma.PostTagFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>[]
}
create: {
args: Prisma.PostTagCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>
}
createMany: {
args: Prisma.PostTagCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.PostTagCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>[]
}
delete: {
args: Prisma.PostTagDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>
}
update: {
args: Prisma.PostTagUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>
}
deleteMany: {
args: Prisma.PostTagDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.PostTagUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.PostTagUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>[]
}
upsert: {
args: Prisma.PostTagUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostTagPayload>
}
aggregate: {
args: Prisma.PostTagAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregatePostTag>
}
groupBy: {
args: Prisma.PostTagGroupByArgs<ExtArgs>
result: $Utils.Optional<PostTagGroupByOutputType>[]
}
count: {
args: Prisma.PostTagCountArgs<ExtArgs>
result: $Utils.Optional<PostTagCountAggregateOutputType> | number
}
}
}
Like: {
payload: Prisma.$LikePayload<ExtArgs>
fields: Prisma.LikeFieldRefs
operations: {
findUnique: {
args: Prisma.LikeFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload> | null
}
findUniqueOrThrow: {
args: Prisma.LikeFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>
}
findFirst: {
args: Prisma.LikeFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload> | null
}
findFirstOrThrow: {
args: Prisma.LikeFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>
}
findMany: {
args: Prisma.LikeFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>[]
}
create: {
args: Prisma.LikeCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>
}
createMany: {
args: Prisma.LikeCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.LikeCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>[]
}
delete: {
args: Prisma.LikeDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>
}
update: {
args: Prisma.LikeUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>
}
deleteMany: {
args: Prisma.LikeDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.LikeUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.LikeUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>[]
}
upsert: {
args: Prisma.LikeUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$LikePayload>
}
aggregate: {
args: Prisma.LikeAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregateLike>
}
groupBy: {
args: Prisma.LikeGroupByArgs<ExtArgs>
result: $Utils.Optional<LikeGroupByOutputType>[]
}
count: {
args: Prisma.LikeCountArgs<ExtArgs>
result: $Utils.Optional<LikeCountAggregateOutputType> | number
}
}
}
Comment: {
payload: Prisma.$CommentPayload<ExtArgs>
fields: Prisma.CommentFieldRefs
operations: {
findUnique: {
args: Prisma.CommentFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload> | null
}
findUniqueOrThrow: {
args: Prisma.CommentFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>
}
findFirst: {
args: Prisma.CommentFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload> | null
}
findFirstOrThrow: {
args: Prisma.CommentFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>
}
findMany: {
args: Prisma.CommentFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>[]
}
create: {
args: Prisma.CommentCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>
}
createMany: {
args: Prisma.CommentCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.CommentCreateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>[]
}
delete: {
args: Prisma.CommentDeleteArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>
}
update: {
args: Prisma.CommentUpdateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>
}
deleteMany: {
args: Prisma.CommentDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.CommentUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.CommentUpdateManyAndReturnArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>[]
}
upsert: {
args: Prisma.CommentUpsertArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$CommentPayload>
}
aggregate: {
args: Prisma.CommentAggregateArgs<ExtArgs>
result: $Utils.Optional<AggregateComment>
}
groupBy: {
args: Prisma.CommentGroupByArgs<ExtArgs>
result: $Utils.Optional<CommentGroupByOutputType>[]
}
count: {
args: Prisma.CommentCountArgs<ExtArgs>
result: $Utils.Optional<CommentCountAggregateOutputType> | number
}
}
}
PostAnalytic: {
payload: Prisma.$PostAnalyticPayload<ExtArgs>
fields: Prisma.PostAnalyticFieldRefs
operations: {
findUnique: {
args: Prisma.PostAnalyticFindUniqueArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostAnalyticPayload> | null
}
findUniqueOrThrow: {
args: Prisma.PostAnalyticFindUniqueOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostAnalyticPayload>
}
findFirst: {
args: Prisma.PostAnalyticFindFirstArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostAnalyticPayload> | null
}
findFirstOrThrow: {
args: Prisma.PostAnalyticFindFirstOrThrowArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostAnalyticPayload>
}
findMany: {
args: Prisma.PostAnalyticFindManyArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostAnalyticPayload>[]
}
create: {
args: Prisma.PostAnalyticCreateArgs<ExtArgs>
result: $Utils.PayloadToResult<Prisma.$PostAnalyticPayload>
}
createMany: {
args: Prisma.PostAnalyticCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.PostAnalyticCreateManyAndReturnArgs<ExtArgs>
result: $Utils