@prenta/core 0.118.0

package/dist/generated/internal/prismaNamespace.d.ts

@@ -0,0 +1,4184 @@
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../models.js";
+import { type PrismaClient } from "./class.js";
+export type * from '../models.js';
+export type DMMF = typeof runtime.DMMF;
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>;
+/**
+ * Prisma Errors
+ */
+export declare const PrismaClientKnownRequestError: typeof runtime.PrismaClientKnownRequestError;
+export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError;
+export declare const PrismaClientUnknownRequestError: typeof runtime.PrismaClientUnknownRequestError;
+export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError;
+export declare const PrismaClientRustPanicError: typeof runtime.PrismaClientRustPanicError;
+export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError;
+export declare const PrismaClientInitializationError: typeof runtime.PrismaClientInitializationError;
+export type PrismaClientInitializationError = runtime.PrismaClientInitializationError;
+export declare const PrismaClientValidationError: typeof runtime.PrismaClientValidationError;
+export type PrismaClientValidationError = runtime.PrismaClientValidationError;
+/**
+ * Re-export of sql-template-tag
+ */
+export declare const sql: typeof runtime.sqltag;
+export declare const empty: runtime.Sql;
+export declare const join: typeof runtime.join;
+export declare const raw: typeof runtime.raw;
+export declare const Sql: typeof runtime.Sql;
+export type Sql = runtime.Sql;
+/**
+ * Decimal.js
+ */
+export declare const Decimal: typeof runtime.Decimal;
+export type Decimal = runtime.Decimal;
+export type DecimalJsLike = runtime.DecimalJsLike;
+/**
+* Extensions
+*/
+export type Extension = runtime.Types.Extensions.UserArgs;
+export declare const getExtensionContext: typeof runtime.Extensions.getExtensionContext;
+export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>;
+export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>;
+export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>;
+export type Exact<A, W> = runtime.Types.Public.Exact<A, W>;
+export type PrismaVersion = {
+    client: string;
+    engine: string;
+};
+/**
+ * Prisma Client JS version: 7.8.0
+ * Query Engine version: 3c6e192761c0362d496ed980de936e2f3cebcd3a
+ */
+export declare const prismaVersion: PrismaVersion;
+/**
+ * Utility Types
+ */
+export type Bytes = runtime.Bytes;
+export type JsonObject = runtime.JsonObject;
+export type JsonArray = runtime.JsonArray;
+export type JsonValue = runtime.JsonValue;
+export type InputJsonObject = runtime.InputJsonObject;
+export type InputJsonArray = runtime.InputJsonArray;
+export type InputJsonValue = runtime.InputJsonValue;
+export declare const NullTypes: {
+    DbNull: (new (secret: never) => typeof runtime.DbNull);
+    JsonNull: (new (secret: never) => typeof runtime.JsonNull);
+    AnyNull: (new (secret: never) => typeof runtime.AnyNull);
+};
+/**
+ * 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 declare const DbNull: runtime.DbNullClass;
+/**
+ * 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 declare const JsonNull: runtime.JsonNullClass;
+/**
+ * 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 declare const AnyNull: runtime.AnyNullClass;
+type SelectAndInclude = {
+    select: any;
+    include: any;
+};
+type SelectAndOmit = {
+    select: any;
+    omit: any;
+};
+/**
+ * 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>;
+/**
+ * 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
+ */
+export 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> & {
+    [P in K]: Prisma__Pick<O, P & keyof O>;
+}[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];
+export type Either<O extends object, K extends Key, strict extends Boolean = 1> = O extends unknown ? _Either<O, K, strict> : never;
+export type Union = any;
+export 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 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;
+};
+type NoExpand<T> = T extends unknown ? T : never;
+export 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>>>;
+export type Boolean = True | False;
+export type True = 1;
+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 : 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;
+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;
+export type GetHavingFields<T> = {
+    [K in keyof T]: Or<Or<Extends<'OR', K>, Extends<'AND', K>>, Extends<'NOT', K>> extends True ? 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>;
+export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T;
+/**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>;
+/**
+ * Exclude all keys with underscores
+ */
+export 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 declare const ModelName: {
+    readonly User: "User";
+    readonly OAuthAccount: "OAuthAccount";
+    readonly Session: "Session";
+    readonly ApiKey: "ApiKey";
+    readonly AuditLog: "AuditLog";
+    readonly Folder: "Folder";
+    readonly Document: "Document";
+    readonly Version: "Version";
+    readonly Media: "Media";
+    readonly MediaUsage: "MediaUsage";
+    readonly ContentLock: "ContentLock";
+    readonly InAppNotification: "InAppNotification";
+    readonly ContentTemplate: "ContentTemplate";
+    readonly Site: "Site";
+    readonly WorkflowState: "WorkflowState";
+    readonly Redirect: "Redirect";
+    readonly SeoAuditRun: "SeoAuditRun";
+    readonly SeoIssue: "SeoIssue";
+    readonly Redirect404Hit: "Redirect404Hit";
+    readonly AiCrawlerHit: "AiCrawlerHit";
+    readonly RedirectSuggestion: "RedirectSuggestion";
+    readonly FormSchemaVersion: "FormSchemaVersion";
+    readonly FormSubmission: "FormSubmission";
+    readonly FormSubmissionFile: "FormSubmissionFile";
+    readonly FormWebhook: "FormWebhook";
+    readonly FormDeliveryAttempt: "FormDeliveryAttempt";
+    readonly BackupRecord: "BackupRecord";
+    readonly WebhookEndpoint: "WebhookEndpoint";
+    readonly WebhookDeliveryLog: "WebhookDeliveryLog";
+    readonly PasswordResetToken: "PasswordResetToken";
+    readonly Invite: "Invite";
+    readonly ScriptTag: "ScriptTag";
+    readonly PageTemplate: "PageTemplate";
+    readonly SavedSection: "SavedSection";
+    readonly ApiRequestMetric: "ApiRequestMetric";
+    readonly ContentIssue: "ContentIssue";
+};
+export type ModelName = (typeof ModelName)[keyof typeof ModelName];
+export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{
+    extArgs: runtime.Types.Extensions.InternalArgs;
+}, runtime.Types.Utils.Record<string, any>> {
+    returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>;
+}
+export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
+    globalOmitOptions: {
+        omit: GlobalOmitOptions;
+    };
+    meta: {
+        modelProps: "user" | "oAuthAccount" | "session" | "apiKey" | "auditLog" | "folder" | "document" | "version" | "media" | "mediaUsage" | "contentLock" | "inAppNotification" | "contentTemplate" | "site" | "workflowState" | "redirect" | "seoAuditRun" | "seoIssue" | "redirect404Hit" | "aiCrawlerHit" | "redirectSuggestion" | "formSchemaVersion" | "formSubmission" | "formSubmissionFile" | "formWebhook" | "formDeliveryAttempt" | "backupRecord" | "webhookEndpoint" | "webhookDeliveryLog" | "passwordResetToken" | "invite" | "scriptTag" | "pageTemplate" | "savedSection" | "apiRequestMetric" | "contentIssue";
+        txIsolationLevel: TransactionIsolationLevel;
+    };
+    model: {
+        User: {
+            payload: Prisma.$UserPayload<ExtArgs>;
+            fields: Prisma.UserFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.UserFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                findFirst: {
+                    args: Prisma.UserFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                findMany: {
+                    args: Prisma.UserFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[];
+                };
+                create: {
+                    args: Prisma.UserCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                createMany: {
+                    args: Prisma.UserCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[];
+                };
+                delete: {
+                    args: Prisma.UserDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                update: {
+                    args: Prisma.UserUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.UserDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.UserUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[];
+                };
+                upsert: {
+                    args: Prisma.UserUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                aggregate: {
+                    args: Prisma.UserAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateUser>;
+                };
+                groupBy: {
+                    args: Prisma.UserGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.UserCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OAuthAccount: {
+            payload: Prisma.$OAuthAccountPayload<ExtArgs>;
+            fields: Prisma.OAuthAccountFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OAuthAccountFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OAuthAccountFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OAuthAccountFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OAuthAccountFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>;
+                };
+                findMany: {
+                    args: Prisma.OAuthAccountFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>[];
+                };
+                create: {
+                    args: Prisma.OAuthAccountCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>;
+                };
+                createMany: {
+                    args: Prisma.OAuthAccountCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OAuthAccountCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>[];
+                };
+                delete: {
+                    args: Prisma.OAuthAccountDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>;
+                };
+                update: {
+                    args: Prisma.OAuthAccountUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OAuthAccountDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OAuthAccountUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OAuthAccountUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OAuthAccountUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAccountPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OAuthAccountAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOAuthAccount>;
+                };
+                groupBy: {
+                    args: Prisma.OAuthAccountGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthAccountGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OAuthAccountCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthAccountCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Session: {
+            payload: Prisma.$SessionPayload<ExtArgs>;
+            fields: Prisma.SessionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SessionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SessionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                findMany: {
+                    args: Prisma.SessionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[];
+                };
+                create: {
+                    args: Prisma.SessionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                createMany: {
+                    args: Prisma.SessionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[];
+                };
+                delete: {
+                    args: Prisma.SessionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                update: {
+                    args: Prisma.SessionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SessionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SessionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SessionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SessionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSession>;
+                };
+                groupBy: {
+                    args: Prisma.SessionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SessionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SessionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SessionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ApiKey: {
+            payload: Prisma.$ApiKeyPayload<ExtArgs>;
+            fields: Prisma.ApiKeyFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ApiKeyFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ApiKeyFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ApiKeyFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ApiKeyFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                findMany: {
+                    args: Prisma.ApiKeyFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>[];
+                };
+                create: {
+                    args: Prisma.ApiKeyCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                createMany: {
+                    args: Prisma.ApiKeyCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ApiKeyCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>[];
+                };
+                delete: {
+                    args: Prisma.ApiKeyDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                update: {
+                    args: Prisma.ApiKeyUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ApiKeyDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ApiKeyUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ApiKeyUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ApiKeyUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ApiKeyAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateApiKey>;
+                };
+                groupBy: {
+                    args: Prisma.ApiKeyGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ApiKeyGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ApiKeyCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ApiKeyCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuditLog: {
+            payload: Prisma.$AuditLogPayload<ExtArgs>;
+            fields: Prisma.AuditLogFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuditLogFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuditLogFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuditLogFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuditLogFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                findMany: {
+                    args: Prisma.AuditLogFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>[];
+                };
+                create: {
+                    args: Prisma.AuditLogCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                createMany: {
+                    args: Prisma.AuditLogCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuditLogCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>[];
+                };
+                delete: {
+                    args: Prisma.AuditLogDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                update: {
+                    args: Prisma.AuditLogUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuditLogDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuditLogUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuditLogUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuditLogUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuditLogAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuditLog>;
+                };
+                groupBy: {
+                    args: Prisma.AuditLogGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuditLogGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuditLogCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuditLogCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Folder: {
+            payload: Prisma.$FolderPayload<ExtArgs>;
+            fields: Prisma.FolderFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FolderFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FolderFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FolderFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FolderFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>;
+                };
+                findMany: {
+                    args: Prisma.FolderFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>[];
+                };
+                create: {
+                    args: Prisma.FolderCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>;
+                };
+                createMany: {
+                    args: Prisma.FolderCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FolderCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>[];
+                };
+                delete: {
+                    args: Prisma.FolderDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>;
+                };
+                update: {
+                    args: Prisma.FolderUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FolderDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FolderUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FolderUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FolderUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FolderPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FolderAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFolder>;
+                };
+                groupBy: {
+                    args: Prisma.FolderGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FolderGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FolderCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FolderCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Document: {
+            payload: Prisma.$DocumentPayload<ExtArgs>;
+            fields: Prisma.DocumentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.DocumentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.DocumentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.DocumentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.DocumentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>;
+                };
+                findMany: {
+                    args: Prisma.DocumentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>[];
+                };
+                create: {
+                    args: Prisma.DocumentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>;
+                };
+                createMany: {
+                    args: Prisma.DocumentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.DocumentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>[];
+                };
+                delete: {
+                    args: Prisma.DocumentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>;
+                };
+                update: {
+                    args: Prisma.DocumentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.DocumentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.DocumentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.DocumentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.DocumentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DocumentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.DocumentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateDocument>;
+                };
+                groupBy: {
+                    args: Prisma.DocumentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.DocumentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.DocumentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.DocumentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Version: {
+            payload: Prisma.$VersionPayload<ExtArgs>;
+            fields: Prisma.VersionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.VersionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.VersionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.VersionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.VersionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>;
+                };
+                findMany: {
+                    args: Prisma.VersionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>[];
+                };
+                create: {
+                    args: Prisma.VersionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>;
+                };
+                createMany: {
+                    args: Prisma.VersionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.VersionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>[];
+                };
+                delete: {
+                    args: Prisma.VersionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>;
+                };
+                update: {
+                    args: Prisma.VersionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.VersionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.VersionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.VersionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.VersionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VersionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.VersionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateVersion>;
+                };
+                groupBy: {
+                    args: Prisma.VersionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.VersionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.VersionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.VersionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Media: {
+            payload: Prisma.$MediaPayload<ExtArgs>;
+            fields: Prisma.MediaFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.MediaFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.MediaFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>;
+                };
+                findFirst: {
+                    args: Prisma.MediaFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.MediaFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>;
+                };
+                findMany: {
+                    args: Prisma.MediaFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>[];
+                };
+                create: {
+                    args: Prisma.MediaCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>;
+                };
+                createMany: {
+                    args: Prisma.MediaCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.MediaCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>[];
+                };
+                delete: {
+                    args: Prisma.MediaDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>;
+                };
+                update: {
+                    args: Prisma.MediaUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.MediaDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.MediaUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.MediaUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>[];
+                };
+                upsert: {
+                    args: Prisma.MediaUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaPayload>;
+                };
+                aggregate: {
+                    args: Prisma.MediaAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateMedia>;
+                };
+                groupBy: {
+                    args: Prisma.MediaGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.MediaGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.MediaCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.MediaCountAggregateOutputType> | number;
+                };
+            };
+        };
+        MediaUsage: {
+            payload: Prisma.$MediaUsagePayload<ExtArgs>;
+            fields: Prisma.MediaUsageFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.MediaUsageFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.MediaUsageFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>;
+                };
+                findFirst: {
+                    args: Prisma.MediaUsageFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.MediaUsageFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>;
+                };
+                findMany: {
+                    args: Prisma.MediaUsageFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>[];
+                };
+                create: {
+                    args: Prisma.MediaUsageCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>;
+                };
+                createMany: {
+                    args: Prisma.MediaUsageCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.MediaUsageCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>[];
+                };
+                delete: {
+                    args: Prisma.MediaUsageDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>;
+                };
+                update: {
+                    args: Prisma.MediaUsageUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.MediaUsageDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.MediaUsageUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.MediaUsageUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>[];
+                };
+                upsert: {
+                    args: Prisma.MediaUsageUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$MediaUsagePayload>;
+                };
+                aggregate: {
+                    args: Prisma.MediaUsageAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateMediaUsage>;
+                };
+                groupBy: {
+                    args: Prisma.MediaUsageGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.MediaUsageGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.MediaUsageCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.MediaUsageCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ContentLock: {
+            payload: Prisma.$ContentLockPayload<ExtArgs>;
+            fields: Prisma.ContentLockFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ContentLockFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ContentLockFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ContentLockFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ContentLockFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>;
+                };
+                findMany: {
+                    args: Prisma.ContentLockFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>[];
+                };
+                create: {
+                    args: Prisma.ContentLockCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>;
+                };
+                createMany: {
+                    args: Prisma.ContentLockCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ContentLockCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>[];
+                };
+                delete: {
+                    args: Prisma.ContentLockDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>;
+                };
+                update: {
+                    args: Prisma.ContentLockUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ContentLockDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ContentLockUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ContentLockUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ContentLockUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentLockPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ContentLockAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateContentLock>;
+                };
+                groupBy: {
+                    args: Prisma.ContentLockGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ContentLockGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ContentLockCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ContentLockCountAggregateOutputType> | number;
+                };
+            };
+        };
+        InAppNotification: {
+            payload: Prisma.$InAppNotificationPayload<ExtArgs>;
+            fields: Prisma.InAppNotificationFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.InAppNotificationFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.InAppNotificationFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>;
+                };
+                findFirst: {
+                    args: Prisma.InAppNotificationFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.InAppNotificationFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>;
+                };
+                findMany: {
+                    args: Prisma.InAppNotificationFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>[];
+                };
+                create: {
+                    args: Prisma.InAppNotificationCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>;
+                };
+                createMany: {
+                    args: Prisma.InAppNotificationCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.InAppNotificationCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>[];
+                };
+                delete: {
+                    args: Prisma.InAppNotificationDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>;
+                };
+                update: {
+                    args: Prisma.InAppNotificationUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.InAppNotificationDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.InAppNotificationUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.InAppNotificationUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>[];
+                };
+                upsert: {
+                    args: Prisma.InAppNotificationUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InAppNotificationPayload>;
+                };
+                aggregate: {
+                    args: Prisma.InAppNotificationAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateInAppNotification>;
+                };
+                groupBy: {
+                    args: Prisma.InAppNotificationGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.InAppNotificationGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.InAppNotificationCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.InAppNotificationCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ContentTemplate: {
+            payload: Prisma.$ContentTemplatePayload<ExtArgs>;
+            fields: Prisma.ContentTemplateFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ContentTemplateFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ContentTemplateFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ContentTemplateFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ContentTemplateFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>;
+                };
+                findMany: {
+                    args: Prisma.ContentTemplateFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>[];
+                };
+                create: {
+                    args: Prisma.ContentTemplateCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>;
+                };
+                createMany: {
+                    args: Prisma.ContentTemplateCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ContentTemplateCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>[];
+                };
+                delete: {
+                    args: Prisma.ContentTemplateDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>;
+                };
+                update: {
+                    args: Prisma.ContentTemplateUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ContentTemplateDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ContentTemplateUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ContentTemplateUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ContentTemplateUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentTemplatePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ContentTemplateAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateContentTemplate>;
+                };
+                groupBy: {
+                    args: Prisma.ContentTemplateGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ContentTemplateGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ContentTemplateCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ContentTemplateCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Site: {
+            payload: Prisma.$SitePayload<ExtArgs>;
+            fields: Prisma.SiteFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SiteFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SiteFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>;
+                };
+                findFirst: {
+                    args: Prisma.SiteFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SiteFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>;
+                };
+                findMany: {
+                    args: Prisma.SiteFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>[];
+                };
+                create: {
+                    args: Prisma.SiteCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>;
+                };
+                createMany: {
+                    args: Prisma.SiteCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SiteCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>[];
+                };
+                delete: {
+                    args: Prisma.SiteDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>;
+                };
+                update: {
+                    args: Prisma.SiteUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SiteDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SiteUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SiteUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>[];
+                };
+                upsert: {
+                    args: Prisma.SiteUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SitePayload>;
+                };
+                aggregate: {
+                    args: Prisma.SiteAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSite>;
+                };
+                groupBy: {
+                    args: Prisma.SiteGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SiteGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SiteCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SiteCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkflowState: {
+            payload: Prisma.$WorkflowStatePayload<ExtArgs>;
+            fields: Prisma.WorkflowStateFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkflowStateFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkflowStateFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkflowStateFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkflowStateFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkflowStateFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>[];
+                };
+                create: {
+                    args: Prisma.WorkflowStateCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkflowStateCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkflowStateCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkflowStateDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>;
+                };
+                update: {
+                    args: Prisma.WorkflowStateUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkflowStateDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkflowStateUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkflowStateUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkflowStateUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowStatePayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkflowStateAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkflowState>;
+                };
+                groupBy: {
+                    args: Prisma.WorkflowStateGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkflowStateGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkflowStateCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkflowStateCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Redirect: {
+            payload: Prisma.$RedirectPayload<ExtArgs>;
+            fields: Prisma.RedirectFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.RedirectFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.RedirectFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>;
+                };
+                findFirst: {
+                    args: Prisma.RedirectFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.RedirectFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>;
+                };
+                findMany: {
+                    args: Prisma.RedirectFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>[];
+                };
+                create: {
+                    args: Prisma.RedirectCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>;
+                };
+                createMany: {
+                    args: Prisma.RedirectCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.RedirectCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>[];
+                };
+                delete: {
+                    args: Prisma.RedirectDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>;
+                };
+                update: {
+                    args: Prisma.RedirectUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.RedirectDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.RedirectUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.RedirectUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>[];
+                };
+                upsert: {
+                    args: Prisma.RedirectUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectPayload>;
+                };
+                aggregate: {
+                    args: Prisma.RedirectAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateRedirect>;
+                };
+                groupBy: {
+                    args: Prisma.RedirectGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RedirectGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.RedirectCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RedirectCountAggregateOutputType> | number;
+                };
+            };
+        };
+        SeoAuditRun: {
+            payload: Prisma.$SeoAuditRunPayload<ExtArgs>;
+            fields: Prisma.SeoAuditRunFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SeoAuditRunFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SeoAuditRunFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SeoAuditRunFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SeoAuditRunFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>;
+                };
+                findMany: {
+                    args: Prisma.SeoAuditRunFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>[];
+                };
+                create: {
+                    args: Prisma.SeoAuditRunCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>;
+                };
+                createMany: {
+                    args: Prisma.SeoAuditRunCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SeoAuditRunCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>[];
+                };
+                delete: {
+                    args: Prisma.SeoAuditRunDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>;
+                };
+                update: {
+                    args: Prisma.SeoAuditRunUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SeoAuditRunDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SeoAuditRunUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SeoAuditRunUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SeoAuditRunUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoAuditRunPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SeoAuditRunAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSeoAuditRun>;
+                };
+                groupBy: {
+                    args: Prisma.SeoAuditRunGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SeoAuditRunGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SeoAuditRunCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SeoAuditRunCountAggregateOutputType> | number;
+                };
+            };
+        };
+        SeoIssue: {
+            payload: Prisma.$SeoIssuePayload<ExtArgs>;
+            fields: Prisma.SeoIssueFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SeoIssueFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SeoIssueFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>;
+                };
+                findFirst: {
+                    args: Prisma.SeoIssueFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SeoIssueFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>;
+                };
+                findMany: {
+                    args: Prisma.SeoIssueFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>[];
+                };
+                create: {
+                    args: Prisma.SeoIssueCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>;
+                };
+                createMany: {
+                    args: Prisma.SeoIssueCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SeoIssueCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>[];
+                };
+                delete: {
+                    args: Prisma.SeoIssueDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>;
+                };
+                update: {
+                    args: Prisma.SeoIssueUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SeoIssueDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SeoIssueUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SeoIssueUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>[];
+                };
+                upsert: {
+                    args: Prisma.SeoIssueUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SeoIssuePayload>;
+                };
+                aggregate: {
+                    args: Prisma.SeoIssueAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSeoIssue>;
+                };
+                groupBy: {
+                    args: Prisma.SeoIssueGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SeoIssueGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SeoIssueCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SeoIssueCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Redirect404Hit: {
+            payload: Prisma.$Redirect404HitPayload<ExtArgs>;
+            fields: Prisma.Redirect404HitFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.Redirect404HitFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.Redirect404HitFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>;
+                };
+                findFirst: {
+                    args: Prisma.Redirect404HitFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.Redirect404HitFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>;
+                };
+                findMany: {
+                    args: Prisma.Redirect404HitFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>[];
+                };
+                create: {
+                    args: Prisma.Redirect404HitCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>;
+                };
+                createMany: {
+                    args: Prisma.Redirect404HitCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.Redirect404HitCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>[];
+                };
+                delete: {
+                    args: Prisma.Redirect404HitDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>;
+                };
+                update: {
+                    args: Prisma.Redirect404HitUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.Redirect404HitDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.Redirect404HitUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.Redirect404HitUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>[];
+                };
+                upsert: {
+                    args: Prisma.Redirect404HitUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$Redirect404HitPayload>;
+                };
+                aggregate: {
+                    args: Prisma.Redirect404HitAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateRedirect404Hit>;
+                };
+                groupBy: {
+                    args: Prisma.Redirect404HitGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.Redirect404HitGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.Redirect404HitCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.Redirect404HitCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AiCrawlerHit: {
+            payload: Prisma.$AiCrawlerHitPayload<ExtArgs>;
+            fields: Prisma.AiCrawlerHitFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AiCrawlerHitFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AiCrawlerHitFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AiCrawlerHitFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AiCrawlerHitFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>;
+                };
+                findMany: {
+                    args: Prisma.AiCrawlerHitFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>[];
+                };
+                create: {
+                    args: Prisma.AiCrawlerHitCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>;
+                };
+                createMany: {
+                    args: Prisma.AiCrawlerHitCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AiCrawlerHitCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>[];
+                };
+                delete: {
+                    args: Prisma.AiCrawlerHitDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>;
+                };
+                update: {
+                    args: Prisma.AiCrawlerHitUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AiCrawlerHitDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AiCrawlerHitUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AiCrawlerHitUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AiCrawlerHitUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AiCrawlerHitPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AiCrawlerHitAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAiCrawlerHit>;
+                };
+                groupBy: {
+                    args: Prisma.AiCrawlerHitGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AiCrawlerHitGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AiCrawlerHitCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AiCrawlerHitCountAggregateOutputType> | number;
+                };
+            };
+        };
+        RedirectSuggestion: {
+            payload: Prisma.$RedirectSuggestionPayload<ExtArgs>;
+            fields: Prisma.RedirectSuggestionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.RedirectSuggestionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.RedirectSuggestionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.RedirectSuggestionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.RedirectSuggestionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>;
+                };
+                findMany: {
+                    args: Prisma.RedirectSuggestionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>[];
+                };
+                create: {
+                    args: Prisma.RedirectSuggestionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>;
+                };
+                createMany: {
+                    args: Prisma.RedirectSuggestionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.RedirectSuggestionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>[];
+                };
+                delete: {
+                    args: Prisma.RedirectSuggestionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>;
+                };
+                update: {
+                    args: Prisma.RedirectSuggestionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.RedirectSuggestionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.RedirectSuggestionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.RedirectSuggestionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.RedirectSuggestionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RedirectSuggestionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.RedirectSuggestionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateRedirectSuggestion>;
+                };
+                groupBy: {
+                    args: Prisma.RedirectSuggestionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RedirectSuggestionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.RedirectSuggestionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RedirectSuggestionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FormSchemaVersion: {
+            payload: Prisma.$FormSchemaVersionPayload<ExtArgs>;
+            fields: Prisma.FormSchemaVersionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FormSchemaVersionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FormSchemaVersionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FormSchemaVersionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FormSchemaVersionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>;
+                };
+                findMany: {
+                    args: Prisma.FormSchemaVersionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>[];
+                };
+                create: {
+                    args: Prisma.FormSchemaVersionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>;
+                };
+                createMany: {
+                    args: Prisma.FormSchemaVersionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FormSchemaVersionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>[];
+                };
+                delete: {
+                    args: Prisma.FormSchemaVersionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>;
+                };
+                update: {
+                    args: Prisma.FormSchemaVersionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FormSchemaVersionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FormSchemaVersionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FormSchemaVersionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FormSchemaVersionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSchemaVersionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FormSchemaVersionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFormSchemaVersion>;
+                };
+                groupBy: {
+                    args: Prisma.FormSchemaVersionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormSchemaVersionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FormSchemaVersionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormSchemaVersionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FormSubmission: {
+            payload: Prisma.$FormSubmissionPayload<ExtArgs>;
+            fields: Prisma.FormSubmissionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FormSubmissionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FormSubmissionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FormSubmissionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FormSubmissionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>;
+                };
+                findMany: {
+                    args: Prisma.FormSubmissionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>[];
+                };
+                create: {
+                    args: Prisma.FormSubmissionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>;
+                };
+                createMany: {
+                    args: Prisma.FormSubmissionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FormSubmissionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>[];
+                };
+                delete: {
+                    args: Prisma.FormSubmissionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>;
+                };
+                update: {
+                    args: Prisma.FormSubmissionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FormSubmissionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FormSubmissionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FormSubmissionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FormSubmissionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FormSubmissionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFormSubmission>;
+                };
+                groupBy: {
+                    args: Prisma.FormSubmissionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormSubmissionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FormSubmissionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormSubmissionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FormSubmissionFile: {
+            payload: Prisma.$FormSubmissionFilePayload<ExtArgs>;
+            fields: Prisma.FormSubmissionFileFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FormSubmissionFileFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FormSubmissionFileFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>;
+                };
+                findFirst: {
+                    args: Prisma.FormSubmissionFileFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FormSubmissionFileFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>;
+                };
+                findMany: {
+                    args: Prisma.FormSubmissionFileFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>[];
+                };
+                create: {
+                    args: Prisma.FormSubmissionFileCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>;
+                };
+                createMany: {
+                    args: Prisma.FormSubmissionFileCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FormSubmissionFileCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>[];
+                };
+                delete: {
+                    args: Prisma.FormSubmissionFileDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>;
+                };
+                update: {
+                    args: Prisma.FormSubmissionFileUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FormSubmissionFileDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FormSubmissionFileUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FormSubmissionFileUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>[];
+                };
+                upsert: {
+                    args: Prisma.FormSubmissionFileUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormSubmissionFilePayload>;
+                };
+                aggregate: {
+                    args: Prisma.FormSubmissionFileAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFormSubmissionFile>;
+                };
+                groupBy: {
+                    args: Prisma.FormSubmissionFileGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormSubmissionFileGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FormSubmissionFileCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormSubmissionFileCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FormWebhook: {
+            payload: Prisma.$FormWebhookPayload<ExtArgs>;
+            fields: Prisma.FormWebhookFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FormWebhookFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FormWebhookFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FormWebhookFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FormWebhookFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>;
+                };
+                findMany: {
+                    args: Prisma.FormWebhookFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>[];
+                };
+                create: {
+                    args: Prisma.FormWebhookCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>;
+                };
+                createMany: {
+                    args: Prisma.FormWebhookCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FormWebhookCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>[];
+                };
+                delete: {
+                    args: Prisma.FormWebhookDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>;
+                };
+                update: {
+                    args: Prisma.FormWebhookUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FormWebhookDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FormWebhookUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FormWebhookUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FormWebhookUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormWebhookPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FormWebhookAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFormWebhook>;
+                };
+                groupBy: {
+                    args: Prisma.FormWebhookGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormWebhookGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FormWebhookCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormWebhookCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FormDeliveryAttempt: {
+            payload: Prisma.$FormDeliveryAttemptPayload<ExtArgs>;
+            fields: Prisma.FormDeliveryAttemptFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FormDeliveryAttemptFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FormDeliveryAttemptFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FormDeliveryAttemptFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FormDeliveryAttemptFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>;
+                };
+                findMany: {
+                    args: Prisma.FormDeliveryAttemptFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>[];
+                };
+                create: {
+                    args: Prisma.FormDeliveryAttemptCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>;
+                };
+                createMany: {
+                    args: Prisma.FormDeliveryAttemptCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FormDeliveryAttemptCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>[];
+                };
+                delete: {
+                    args: Prisma.FormDeliveryAttemptDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>;
+                };
+                update: {
+                    args: Prisma.FormDeliveryAttemptUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FormDeliveryAttemptDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FormDeliveryAttemptUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FormDeliveryAttemptUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FormDeliveryAttemptUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FormDeliveryAttemptPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FormDeliveryAttemptAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFormDeliveryAttempt>;
+                };
+                groupBy: {
+                    args: Prisma.FormDeliveryAttemptGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormDeliveryAttemptGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FormDeliveryAttemptCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FormDeliveryAttemptCountAggregateOutputType> | number;
+                };
+            };
+        };
+        BackupRecord: {
+            payload: Prisma.$BackupRecordPayload<ExtArgs>;
+            fields: Prisma.BackupRecordFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.BackupRecordFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.BackupRecordFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>;
+                };
+                findFirst: {
+                    args: Prisma.BackupRecordFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.BackupRecordFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>;
+                };
+                findMany: {
+                    args: Prisma.BackupRecordFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>[];
+                };
+                create: {
+                    args: Prisma.BackupRecordCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>;
+                };
+                createMany: {
+                    args: Prisma.BackupRecordCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.BackupRecordCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>[];
+                };
+                delete: {
+                    args: Prisma.BackupRecordDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>;
+                };
+                update: {
+                    args: Prisma.BackupRecordUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.BackupRecordDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.BackupRecordUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.BackupRecordUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>[];
+                };
+                upsert: {
+                    args: Prisma.BackupRecordUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BackupRecordPayload>;
+                };
+                aggregate: {
+                    args: Prisma.BackupRecordAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateBackupRecord>;
+                };
+                groupBy: {
+                    args: Prisma.BackupRecordGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.BackupRecordGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.BackupRecordCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.BackupRecordCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WebhookEndpoint: {
+            payload: Prisma.$WebhookEndpointPayload<ExtArgs>;
+            fields: Prisma.WebhookEndpointFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WebhookEndpointFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WebhookEndpointFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WebhookEndpointFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WebhookEndpointFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>;
+                };
+                findMany: {
+                    args: Prisma.WebhookEndpointFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>[];
+                };
+                create: {
+                    args: Prisma.WebhookEndpointCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>;
+                };
+                createMany: {
+                    args: Prisma.WebhookEndpointCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WebhookEndpointCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>[];
+                };
+                delete: {
+                    args: Prisma.WebhookEndpointDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>;
+                };
+                update: {
+                    args: Prisma.WebhookEndpointUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WebhookEndpointDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WebhookEndpointUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WebhookEndpointUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WebhookEndpointUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookEndpointPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WebhookEndpointAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWebhookEndpoint>;
+                };
+                groupBy: {
+                    args: Prisma.WebhookEndpointGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WebhookEndpointGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WebhookEndpointCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WebhookEndpointCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WebhookDeliveryLog: {
+            payload: Prisma.$WebhookDeliveryLogPayload<ExtArgs>;
+            fields: Prisma.WebhookDeliveryLogFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WebhookDeliveryLogFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WebhookDeliveryLogFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WebhookDeliveryLogFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WebhookDeliveryLogFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>;
+                };
+                findMany: {
+                    args: Prisma.WebhookDeliveryLogFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>[];
+                };
+                create: {
+                    args: Prisma.WebhookDeliveryLogCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>;
+                };
+                createMany: {
+                    args: Prisma.WebhookDeliveryLogCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WebhookDeliveryLogCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>[];
+                };
+                delete: {
+                    args: Prisma.WebhookDeliveryLogDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>;
+                };
+                update: {
+                    args: Prisma.WebhookDeliveryLogUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WebhookDeliveryLogDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WebhookDeliveryLogUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WebhookDeliveryLogUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WebhookDeliveryLogUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookDeliveryLogPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WebhookDeliveryLogAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWebhookDeliveryLog>;
+                };
+                groupBy: {
+                    args: Prisma.WebhookDeliveryLogGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WebhookDeliveryLogGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WebhookDeliveryLogCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WebhookDeliveryLogCountAggregateOutputType> | number;
+                };
+            };
+        };
+        PasswordResetToken: {
+            payload: Prisma.$PasswordResetTokenPayload<ExtArgs>;
+            fields: Prisma.PasswordResetTokenFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PasswordResetTokenFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PasswordResetTokenFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>;
+                };
+                findFirst: {
+                    args: Prisma.PasswordResetTokenFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PasswordResetTokenFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>;
+                };
+                findMany: {
+                    args: Prisma.PasswordResetTokenFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>[];
+                };
+                create: {
+                    args: Prisma.PasswordResetTokenCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>;
+                };
+                createMany: {
+                    args: Prisma.PasswordResetTokenCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PasswordResetTokenCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>[];
+                };
+                delete: {
+                    args: Prisma.PasswordResetTokenDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>;
+                };
+                update: {
+                    args: Prisma.PasswordResetTokenUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PasswordResetTokenDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PasswordResetTokenUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PasswordResetTokenUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>[];
+                };
+                upsert: {
+                    args: Prisma.PasswordResetTokenUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>;
+                };
+                aggregate: {
+                    args: Prisma.PasswordResetTokenAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePasswordResetToken>;
+                };
+                groupBy: {
+                    args: Prisma.PasswordResetTokenGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PasswordResetTokenGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PasswordResetTokenCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PasswordResetTokenCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Invite: {
+            payload: Prisma.$InvitePayload<ExtArgs>;
+            fields: Prisma.InviteFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.InviteFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.InviteFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>;
+                };
+                findFirst: {
+                    args: Prisma.InviteFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.InviteFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>;
+                };
+                findMany: {
+                    args: Prisma.InviteFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>[];
+                };
+                create: {
+                    args: Prisma.InviteCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>;
+                };
+                createMany: {
+                    args: Prisma.InviteCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.InviteCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>[];
+                };
+                delete: {
+                    args: Prisma.InviteDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>;
+                };
+                update: {
+                    args: Prisma.InviteUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.InviteDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.InviteUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.InviteUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>[];
+                };
+                upsert: {
+                    args: Prisma.InviteUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvitePayload>;
+                };
+                aggregate: {
+                    args: Prisma.InviteAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateInvite>;
+                };
+                groupBy: {
+                    args: Prisma.InviteGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.InviteGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.InviteCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.InviteCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ScriptTag: {
+            payload: Prisma.$ScriptTagPayload<ExtArgs>;
+            fields: Prisma.ScriptTagFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ScriptTagFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ScriptTagFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ScriptTagFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ScriptTagFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>;
+                };
+                findMany: {
+                    args: Prisma.ScriptTagFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>[];
+                };
+                create: {
+                    args: Prisma.ScriptTagCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>;
+                };
+                createMany: {
+                    args: Prisma.ScriptTagCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ScriptTagCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>[];
+                };
+                delete: {
+                    args: Prisma.ScriptTagDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>;
+                };
+                update: {
+                    args: Prisma.ScriptTagUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ScriptTagDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ScriptTagUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ScriptTagUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ScriptTagUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ScriptTagPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ScriptTagAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateScriptTag>;
+                };
+                groupBy: {
+                    args: Prisma.ScriptTagGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ScriptTagGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ScriptTagCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ScriptTagCountAggregateOutputType> | number;
+                };
+            };
+        };
+        PageTemplate: {
+            payload: Prisma.$PageTemplatePayload<ExtArgs>;
+            fields: Prisma.PageTemplateFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PageTemplateFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PageTemplateFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>;
+                };
+                findFirst: {
+                    args: Prisma.PageTemplateFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PageTemplateFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>;
+                };
+                findMany: {
+                    args: Prisma.PageTemplateFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>[];
+                };
+                create: {
+                    args: Prisma.PageTemplateCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>;
+                };
+                createMany: {
+                    args: Prisma.PageTemplateCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PageTemplateCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>[];
+                };
+                delete: {
+                    args: Prisma.PageTemplateDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>;
+                };
+                update: {
+                    args: Prisma.PageTemplateUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PageTemplateDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PageTemplateUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PageTemplateUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>[];
+                };
+                upsert: {
+                    args: Prisma.PageTemplateUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PageTemplatePayload>;
+                };
+                aggregate: {
+                    args: Prisma.PageTemplateAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePageTemplate>;
+                };
+                groupBy: {
+                    args: Prisma.PageTemplateGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PageTemplateGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PageTemplateCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PageTemplateCountAggregateOutputType> | number;
+                };
+            };
+        };
+        SavedSection: {
+            payload: Prisma.$SavedSectionPayload<ExtArgs>;
+            fields: Prisma.SavedSectionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SavedSectionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SavedSectionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SavedSectionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SavedSectionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>;
+                };
+                findMany: {
+                    args: Prisma.SavedSectionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>[];
+                };
+                create: {
+                    args: Prisma.SavedSectionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>;
+                };
+                createMany: {
+                    args: Prisma.SavedSectionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SavedSectionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>[];
+                };
+                delete: {
+                    args: Prisma.SavedSectionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>;
+                };
+                update: {
+                    args: Prisma.SavedSectionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SavedSectionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SavedSectionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SavedSectionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SavedSectionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SavedSectionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SavedSectionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSavedSection>;
+                };
+                groupBy: {
+                    args: Prisma.SavedSectionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SavedSectionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SavedSectionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SavedSectionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ApiRequestMetric: {
+            payload: Prisma.$ApiRequestMetricPayload<ExtArgs>;
+            fields: Prisma.ApiRequestMetricFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ApiRequestMetricFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ApiRequestMetricFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ApiRequestMetricFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ApiRequestMetricFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>;
+                };
+                findMany: {
+                    args: Prisma.ApiRequestMetricFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>[];
+                };
+                create: {
+                    args: Prisma.ApiRequestMetricCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>;
+                };
+                createMany: {
+                    args: Prisma.ApiRequestMetricCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ApiRequestMetricCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>[];
+                };
+                delete: {
+                    args: Prisma.ApiRequestMetricDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>;
+                };
+                update: {
+                    args: Prisma.ApiRequestMetricUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ApiRequestMetricDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ApiRequestMetricUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ApiRequestMetricUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ApiRequestMetricUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiRequestMetricPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ApiRequestMetricAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateApiRequestMetric>;
+                };
+                groupBy: {
+                    args: Prisma.ApiRequestMetricGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ApiRequestMetricGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ApiRequestMetricCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ApiRequestMetricCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ContentIssue: {
+            payload: Prisma.$ContentIssuePayload<ExtArgs>;
+            fields: Prisma.ContentIssueFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ContentIssueFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ContentIssueFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ContentIssueFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ContentIssueFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>;
+                };
+                findMany: {
+                    args: Prisma.ContentIssueFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>[];
+                };
+                create: {
+                    args: Prisma.ContentIssueCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>;
+                };
+                createMany: {
+                    args: Prisma.ContentIssueCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ContentIssueCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>[];
+                };
+                delete: {
+                    args: Prisma.ContentIssueDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>;
+                };
+                update: {
+                    args: Prisma.ContentIssueUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ContentIssueDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ContentIssueUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ContentIssueUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ContentIssueUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ContentIssuePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ContentIssueAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateContentIssue>;
+                };
+                groupBy: {
+                    args: Prisma.ContentIssueGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ContentIssueGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ContentIssueCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ContentIssueCountAggregateOutputType> | number;
+                };
+            };
+        };
+    };
+} & {
+    other: {
+        payload: any;
+        operations: {
+            $executeRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $executeRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+            $queryRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $queryRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+        };
+    };
+};
+/**
+ * Enums
+ */
+export declare const TransactionIsolationLevel: {
+    readonly ReadUncommitted: "ReadUncommitted";
+    readonly ReadCommitted: "ReadCommitted";
+    readonly RepeatableRead: "RepeatableRead";
+    readonly Serializable: "Serializable";
+};
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel];
+export declare const UserScalarFieldEnum: {
+    readonly id: "id";
+    readonly email: "email";
+    readonly name: "name";
+    readonly avatarUrl: "avatarUrl";
+    readonly role: "role";
+    readonly passwordHash: "passwordHash";
+    readonly totpSecret: "totpSecret";
+    readonly totpEnabled: "totpEnabled";
+    readonly lastTotpStep: "lastTotpStep";
+    readonly backupCodes: "backupCodes";
+    readonly authProvider: "authProvider";
+    readonly isActive: "isActive";
+    readonly isApproved: "isApproved";
+    readonly emailVerified: "emailVerified";
+    readonly lastLoginAt: "lastLoginAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly suspendedAt: "suspendedAt";
+    readonly lockedAt: "lockedAt";
+    readonly forcePasswordReset: "forcePasswordReset";
+    readonly mfaRequired: "mfaRequired";
+    readonly failedLoginCount: "failedLoginCount";
+    readonly lastActiveAt: "lastActiveAt";
+    readonly invitedById: "invitedById";
+    readonly acceptedInviteAt: "acceptedInviteAt";
+};
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum];
+export declare const RelationLoadStrategy: {
+    readonly query: "query";
+    readonly join: "join";
+};
+export type RelationLoadStrategy = (typeof RelationLoadStrategy)[keyof typeof RelationLoadStrategy];
+export declare const OAuthAccountScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly provider: "provider";
+    readonly providerAccountId: "providerAccountId";
+    readonly accessToken: "accessToken";
+    readonly refreshToken: "refreshToken";
+    readonly expiresAt: "expiresAt";
+    readonly createdAt: "createdAt";
+};
+export type OAuthAccountScalarFieldEnum = (typeof OAuthAccountScalarFieldEnum)[keyof typeof OAuthAccountScalarFieldEnum];
+export declare const SessionScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly token: "token";
+    readonly expiresAt: "expiresAt";
+    readonly revokedAt: "revokedAt";
+    readonly ipAddress: "ipAddress";
+    readonly userAgent: "userAgent";
+    readonly fingerprintHash: "fingerprintHash";
+    readonly createdAt: "createdAt";
+};
+export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum];
+export declare const ApiKeyScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly keyHash: "keyHash";
+    readonly keyPrefix: "keyPrefix";
+    readonly userId: "userId";
+    readonly scopes: "scopes";
+    readonly ipRestrictions: "ipRestrictions";
+    readonly expiresAt: "expiresAt";
+    readonly lastUsedAt: "lastUsedAt";
+    readonly revokedAt: "revokedAt";
+    readonly createdAt: "createdAt";
+};
+export type ApiKeyScalarFieldEnum = (typeof ApiKeyScalarFieldEnum)[keyof typeof ApiKeyScalarFieldEnum];
+export declare const AuditLogScalarFieldEnum: {
+    readonly id: "id";
+    readonly event: "event";
+    readonly userId: "userId";
+    readonly ipAddress: "ipAddress";
+    readonly userAgent: "userAgent";
+    readonly details: "details";
+    readonly timestamp: "timestamp";
+};
+export type AuditLogScalarFieldEnum = (typeof AuditLogScalarFieldEnum)[keyof typeof AuditLogScalarFieldEnum];
+export declare const FolderScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly scope: "scope";
+    readonly parentId: "parentId";
+    readonly position: "position";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type FolderScalarFieldEnum = (typeof FolderScalarFieldEnum)[keyof typeof FolderScalarFieldEnum];
+export declare const DocumentScalarFieldEnum: {
+    readonly id: "id";
+    readonly collection: "collection";
+    readonly title: "title";
+    readonly slug: "slug";
+    readonly data: "data";
+    readonly status: "status";
+    readonly locale: "locale";
+    readonly localeGroupId: "localeGroupId";
+    readonly createdById: "createdById";
+    readonly updatedById: "updatedById";
+    readonly publishedAt: "publishedAt";
+    readonly scheduledAt: "scheduledAt";
+    readonly scheduledUnpublishAt: "scheduledUnpublishAt";
+    readonly deletedAt: "deletedAt";
+    readonly plainText: "plainText";
+    readonly contentHash: "contentHash";
+    readonly structuredData: "structuredData";
+    readonly contentGraph: "contentGraph";
+    readonly siteId: "siteId";
+    readonly templateId: "templateId";
+    readonly workflowStage: "workflowStage";
+    readonly reviewerId: "reviewerId";
+    readonly reviewNote: "reviewNote";
+    readonly folderId: "folderId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type DocumentScalarFieldEnum = (typeof DocumentScalarFieldEnum)[keyof typeof DocumentScalarFieldEnum];
+export declare const VersionScalarFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly data: "data";
+    readonly changedById: "changedById";
+    readonly changeType: "changeType";
+    readonly createdAt: "createdAt";
+};
+export type VersionScalarFieldEnum = (typeof VersionScalarFieldEnum)[keyof typeof VersionScalarFieldEnum];
+export declare const MediaScalarFieldEnum: {
+    readonly id: "id";
+    readonly filename: "filename";
+    readonly storageKey: "storageKey";
+    readonly mimeType: "mimeType";
+    readonly fileSize: "fileSize";
+    readonly width: "width";
+    readonly height: "height";
+    readonly altText: "altText";
+    readonly title: "title";
+    readonly uploadedById: "uploadedById";
+    readonly focalPointX: "focalPointX";
+    readonly focalPointY: "focalPointY";
+    readonly blurHash: "blurHash";
+    readonly aiAltText: "aiAltText";
+    readonly aiTags: "aiTags";
+    readonly aiDescription: "aiDescription";
+    readonly folderId: "folderId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly originalFileName: "originalFileName";
+    readonly caption: "caption";
+    readonly description: "description";
+    readonly focusKeyword: "focusKeyword";
+    readonly isDecorative: "isDecorative";
+    readonly tags: "tags";
+    readonly contentHash: "contentHash";
+    readonly publicUrl: "publicUrl";
+    readonly storageProvider: "storageProvider";
+    readonly durationSeconds: "durationSeconds";
+    readonly thumbnailUrl: "thumbnailUrl";
+    readonly responsiveVariants: "responsiveVariants";
+    readonly status: "status";
+    readonly deletedAt: "deletedAt";
+};
+export type MediaScalarFieldEnum = (typeof MediaScalarFieldEnum)[keyof typeof MediaScalarFieldEnum];
+export declare const MediaUsageScalarFieldEnum: {
+    readonly id: "id";
+    readonly mediaId: "mediaId";
+    readonly documentId: "documentId";
+    readonly fieldPath: "fieldPath";
+    readonly createdAt: "createdAt";
+};
+export type MediaUsageScalarFieldEnum = (typeof MediaUsageScalarFieldEnum)[keyof typeof MediaUsageScalarFieldEnum];
+export declare const ContentLockScalarFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly userId: "userId";
+    readonly lockedAt: "lockedAt";
+    readonly expiresAt: "expiresAt";
+};
+export type ContentLockScalarFieldEnum = (typeof ContentLockScalarFieldEnum)[keyof typeof ContentLockScalarFieldEnum];
+export declare const InAppNotificationScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly type: "type";
+    readonly title: "title";
+    readonly message: "message";
+    readonly link: "link";
+    readonly read: "read";
+    readonly createdAt: "createdAt";
+};
+export type InAppNotificationScalarFieldEnum = (typeof InAppNotificationScalarFieldEnum)[keyof typeof InAppNotificationScalarFieldEnum];
+export declare const ContentTemplateScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly collection: "collection";
+    readonly templateData: "templateData";
+    readonly createdById: "createdById";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type ContentTemplateScalarFieldEnum = (typeof ContentTemplateScalarFieldEnum)[keyof typeof ContentTemplateScalarFieldEnum];
+export declare const SiteScalarFieldEnum: {
+    readonly id: "id";
+    readonly domain: "domain";
+    readonly name: "name";
+    readonly configOverrides: "configOverrides";
+    readonly isDefault: "isDefault";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type SiteScalarFieldEnum = (typeof SiteScalarFieldEnum)[keyof typeof SiteScalarFieldEnum];
+export declare const WorkflowStateScalarFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly currentStep: "currentStep";
+    readonly assignedToId: "assignedToId";
+    readonly status: "status";
+    readonly definition: "definition";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type WorkflowStateScalarFieldEnum = (typeof WorkflowStateScalarFieldEnum)[keyof typeof WorkflowStateScalarFieldEnum];
+export declare const RedirectScalarFieldEnum: {
+    readonly id: "id";
+    readonly source: "source";
+    readonly destination: "destination";
+    readonly statusCode: "statusCode";
+    readonly isRegex: "isRegex";
+    readonly notes: "notes";
+    readonly enabled: "enabled";
+    readonly priority: "priority";
+    readonly preserveQuery: "preserveQuery";
+    readonly source_kind: "source_kind";
+    readonly hits: "hits";
+    readonly lastHitAt: "lastHitAt";
+    readonly createdById: "createdById";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type RedirectScalarFieldEnum = (typeof RedirectScalarFieldEnum)[keyof typeof RedirectScalarFieldEnum];
+export declare const SeoAuditRunScalarFieldEnum: {
+    readonly id: "id";
+    readonly status: "status";
+    readonly scope: "scope";
+    readonly startedById: "startedById";
+    readonly startedAt: "startedAt";
+    readonly finishedAt: "finishedAt";
+    readonly siteScoreBefore: "siteScoreBefore";
+    readonly siteScoreAfter: "siteScoreAfter";
+    readonly pagesScanned: "pagesScanned";
+    readonly issuesFound: "issuesFound";
+    readonly criticalCount: "criticalCount";
+    readonly warningCount: "warningCount";
+    readonly infoCount: "infoCount";
+    readonly errorMessage: "errorMessage";
+    readonly metadata: "metadata";
+};
+export type SeoAuditRunScalarFieldEnum = (typeof SeoAuditRunScalarFieldEnum)[keyof typeof SeoAuditRunScalarFieldEnum];
+export declare const SeoIssueScalarFieldEnum: {
+    readonly id: "id";
+    readonly auditRunId: "auditRunId";
+    readonly issueKey: "issueKey";
+    readonly entityType: "entityType";
+    readonly entityId: "entityId";
+    readonly entityTitle: "entityTitle";
+    readonly url: "url";
+    readonly severity: "severity";
+    readonly category: "category";
+    readonly type: "type";
+    readonly title: "title";
+    readonly description: "description";
+    readonly impact: "impact";
+    readonly recommendation: "recommendation";
+    readonly status: "status";
+    readonly fixable: "fixable";
+    readonly fixActionType: "fixActionType";
+    readonly relatedEntityIds: "relatedEntityIds";
+    readonly source: "source";
+    readonly firstDetectedAt: "firstDetectedAt";
+    readonly lastDetectedAt: "lastDetectedAt";
+    readonly resolvedAt: "resolvedAt";
+    readonly resolvedById: "resolvedById";
+    readonly metadata: "metadata";
+};
+export type SeoIssueScalarFieldEnum = (typeof SeoIssueScalarFieldEnum)[keyof typeof SeoIssueScalarFieldEnum];
+export declare const Redirect404HitScalarFieldEnum: {
+    readonly id: "id";
+    readonly path: "path";
+    readonly hits: "hits";
+    readonly referrer: "referrer";
+    readonly resolvedAt: "resolvedAt";
+    readonly firstSeenAt: "firstSeenAt";
+    readonly lastSeenAt: "lastSeenAt";
+};
+export type Redirect404HitScalarFieldEnum = (typeof Redirect404HitScalarFieldEnum)[keyof typeof Redirect404HitScalarFieldEnum];
+export declare const AiCrawlerHitScalarFieldEnum: {
+    readonly id: "id";
+    readonly bot: "bot";
+    readonly surface: "surface";
+    readonly category: "category";
+    readonly hits: "hits";
+    readonly firstSeenAt: "firstSeenAt";
+    readonly lastSeenAt: "lastSeenAt";
+};
+export type AiCrawlerHitScalarFieldEnum = (typeof AiCrawlerHitScalarFieldEnum)[keyof typeof AiCrawlerHitScalarFieldEnum];
+export declare const RedirectSuggestionScalarFieldEnum: {
+    readonly id: "id";
+    readonly fromPath: "fromPath";
+    readonly toPath: "toPath";
+    readonly confidence: "confidence";
+    readonly reason: "reason";
+    readonly status: "status";
+    readonly source: "source";
+    readonly metadata: "metadata";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type RedirectSuggestionScalarFieldEnum = (typeof RedirectSuggestionScalarFieldEnum)[keyof typeof RedirectSuggestionScalarFieldEnum];
+export declare const FormSchemaVersionScalarFieldEnum: {
+    readonly id: "id";
+    readonly formId: "formId";
+    readonly version: "version";
+    readonly fields: "fields";
+    readonly notes: "notes";
+    readonly createdById: "createdById";
+    readonly createdAt: "createdAt";
+};
+export type FormSchemaVersionScalarFieldEnum = (typeof FormSchemaVersionScalarFieldEnum)[keyof typeof FormSchemaVersionScalarFieldEnum];
+export declare const FormSubmissionScalarFieldEnum: {
+    readonly id: "id";
+    readonly entryNumber: "entryNumber";
+    readonly formId: "formId";
+    readonly schemaVersionId: "schemaVersionId";
+    readonly data: "data";
+    readonly normalizedData: "normalizedData";
+    readonly attribution: "attribution";
+    readonly senderName: "senderName";
+    readonly senderEmail: "senderEmail";
+    readonly senderPhone: "senderPhone";
+    readonly preview: "preview";
+    readonly status: "status";
+    readonly unread: "unread";
+    readonly starred: "starred";
+    readonly archived: "archived";
+    readonly spamStatus: "spamStatus";
+    readonly ipAddressHash: "ipAddressHash";
+    readonly userAgent: "userAgent";
+    readonly referrer: "referrer";
+    readonly pageUrl: "pageUrl";
+    readonly utmSource: "utmSource";
+    readonly utmMedium: "utmMedium";
+    readonly utmCampaign: "utmCampaign";
+    readonly submittedAt: "submittedAt";
+    readonly readAt: "readAt";
+    readonly archivedAt: "archivedAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type FormSubmissionScalarFieldEnum = (typeof FormSubmissionScalarFieldEnum)[keyof typeof FormSubmissionScalarFieldEnum];
+export declare const FormSubmissionFileScalarFieldEnum: {
+    readonly id: "id";
+    readonly submissionId: "submissionId";
+    readonly fieldKey: "fieldKey";
+    readonly mediaAssetId: "mediaAssetId";
+    readonly fileName: "fileName";
+    readonly mimeType: "mimeType";
+    readonly sizeBytes: "sizeBytes";
+    readonly storageKey: "storageKey";
+    readonly publicUrl: "publicUrl";
+    readonly secureDownloadUrl: "secureDownloadUrl";
+    readonly createdAt: "createdAt";
+};
+export type FormSubmissionFileScalarFieldEnum = (typeof FormSubmissionFileScalarFieldEnum)[keyof typeof FormSubmissionFileScalarFieldEnum];
+export declare const FormWebhookScalarFieldEnum: {
+    readonly id: "id";
+    readonly formId: "formId";
+    readonly url: "url";
+    readonly secret: "secret";
+    readonly previousSecret: "previousSecret";
+    readonly previousSecretValidUntil: "previousSecretValidUntil";
+    readonly enabled: "enabled";
+    readonly events: "events";
+    readonly retryCount: "retryCount";
+    readonly lastDeliveryAt: "lastDeliveryAt";
+    readonly lastDeliveryStatus: "lastDeliveryStatus";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type FormWebhookScalarFieldEnum = (typeof FormWebhookScalarFieldEnum)[keyof typeof FormWebhookScalarFieldEnum];
+export declare const FormDeliveryAttemptScalarFieldEnum: {
+    readonly id: "id";
+    readonly submissionId: "submissionId";
+    readonly formId: "formId";
+    readonly channel: "channel";
+    readonly destination: "destination";
+    readonly webhookId: "webhookId";
+    readonly status: "status";
+    readonly attempts: "attempts";
+    readonly maxAttempts: "maxAttempts";
+    readonly lastAttemptAt: "lastAttemptAt";
+    readonly nextRetryAt: "nextRetryAt";
+    readonly error: "error";
+    readonly responseStatus: "responseStatus";
+    readonly skippedReason: "skippedReason";
+    readonly payload: "payload";
+    readonly alertedAt: "alertedAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type FormDeliveryAttemptScalarFieldEnum = (typeof FormDeliveryAttemptScalarFieldEnum)[keyof typeof FormDeliveryAttemptScalarFieldEnum];
+export declare const BackupRecordScalarFieldEnum: {
+    readonly id: "id";
+    readonly filename: "filename";
+    readonly storageKey: "storageKey";
+    readonly sizeBytes: "sizeBytes";
+    readonly type: "type";
+    readonly metadata: "metadata";
+    readonly createdAt: "createdAt";
+};
+export type BackupRecordScalarFieldEnum = (typeof BackupRecordScalarFieldEnum)[keyof typeof BackupRecordScalarFieldEnum];
+export declare const WebhookEndpointScalarFieldEnum: {
+    readonly id: "id";
+    readonly url: "url";
+    readonly events: "events";
+    readonly secret: "secret";
+    readonly previousSecret: "previousSecret";
+    readonly previousSecretValidUntil: "previousSecretValidUntil";
+    readonly active: "active";
+    readonly name: "name";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type WebhookEndpointScalarFieldEnum = (typeof WebhookEndpointScalarFieldEnum)[keyof typeof WebhookEndpointScalarFieldEnum];
+export declare const WebhookDeliveryLogScalarFieldEnum: {
+    readonly id: "id";
+    readonly endpointId: "endpointId";
+    readonly event: "event";
+    readonly payload: "payload";
+    readonly status: "status";
+    readonly attempts: "attempts";
+    readonly maxAttempts: "maxAttempts";
+    readonly lastAttemptAt: "lastAttemptAt";
+    readonly nextRetryAt: "nextRetryAt";
+    readonly responseStatus: "responseStatus";
+    readonly responseBody: "responseBody";
+    readonly createdAt: "createdAt";
+};
+export type WebhookDeliveryLogScalarFieldEnum = (typeof WebhookDeliveryLogScalarFieldEnum)[keyof typeof WebhookDeliveryLogScalarFieldEnum];
+export declare const PasswordResetTokenScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly tokenHash: "tokenHash";
+    readonly expiresAt: "expiresAt";
+    readonly usedAt: "usedAt";
+    readonly createdAt: "createdAt";
+};
+export type PasswordResetTokenScalarFieldEnum = (typeof PasswordResetTokenScalarFieldEnum)[keyof typeof PasswordResetTokenScalarFieldEnum];
+export declare const InviteScalarFieldEnum: {
+    readonly id: "id";
+    readonly email: "email";
+    readonly role: "role";
+    readonly status: "status";
+    readonly tokenHash: "tokenHash";
+    readonly message: "message";
+    readonly invitedByUserId: "invitedByUserId";
+    readonly acceptedUserId: "acceptedUserId";
+    readonly expiresAt: "expiresAt";
+    readonly acceptedAt: "acceptedAt";
+    readonly cancelledAt: "cancelledAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type InviteScalarFieldEnum = (typeof InviteScalarFieldEnum)[keyof typeof InviteScalarFieldEnum];
+export declare const ScriptTagScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly code: "code";
+    readonly placement: "placement";
+    readonly scope: "scope";
+    readonly targetPaths: "targetPaths";
+    readonly priority: "priority";
+    readonly enabled: "enabled";
+    readonly loadAsync: "loadAsync";
+    readonly disableInPreview: "disableInPreview";
+    readonly consentCategory: "consentCategory";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type ScriptTagScalarFieldEnum = (typeof ScriptTagScalarFieldEnum)[keyof typeof ScriptTagScalarFieldEnum];
+export declare const PageTemplateScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly description: "description";
+    readonly category: "category";
+    readonly tree: "tree";
+    readonly thumbnail: "thumbnail";
+    readonly builtIn: "builtIn";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type PageTemplateScalarFieldEnum = (typeof PageTemplateScalarFieldEnum)[keyof typeof PageTemplateScalarFieldEnum];
+export declare const SavedSectionScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly description: "description";
+    readonly category: "category";
+    readonly tree: "tree";
+    readonly thumbnail: "thumbnail";
+    readonly usageCount: "usageCount";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type SavedSectionScalarFieldEnum = (typeof SavedSectionScalarFieldEnum)[keyof typeof SavedSectionScalarFieldEnum];
+export declare const ApiRequestMetricScalarFieldEnum: {
+    readonly id: "id";
+    readonly bucketStart: "bucketStart";
+    readonly route: "route";
+    readonly statusBucket: "statusBucket";
+    readonly count: "count";
+    readonly sumLatencyMs: "sumLatencyMs";
+    readonly maxLatencyMs: "maxLatencyMs";
+    readonly latencyHistogram: "latencyHistogram";
+    readonly updatedAt: "updatedAt";
+};
+export type ApiRequestMetricScalarFieldEnum = (typeof ApiRequestMetricScalarFieldEnum)[keyof typeof ApiRequestMetricScalarFieldEnum];
+export declare const ContentIssueScalarFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly type: "type";
+    readonly count: "count";
+    readonly details: "details";
+    readonly firstSeenAt: "firstSeenAt";
+    readonly lastSeenAt: "lastSeenAt";
+};
+export type ContentIssueScalarFieldEnum = (typeof ContentIssueScalarFieldEnum)[keyof typeof ContentIssueScalarFieldEnum];
+export declare const SortOrder: {
+    readonly asc: "asc";
+    readonly desc: "desc";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+export declare const NullableJsonNullValueInput: {
+    readonly DbNull: runtime.DbNullClass;
+    readonly JsonNull: runtime.JsonNullClass;
+};
+export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput];
+export declare const JsonNullValueInput: {
+    readonly JsonNull: runtime.JsonNullClass;
+};
+export type JsonNullValueInput = (typeof JsonNullValueInput)[keyof typeof JsonNullValueInput];
+export declare const QueryMode: {
+    readonly default: "default";
+    readonly insensitive: "insensitive";
+};
+export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode];
+export declare const JsonNullValueFilter: {
+    readonly DbNull: runtime.DbNullClass;
+    readonly JsonNull: runtime.JsonNullClass;
+    readonly AnyNull: runtime.AnyNullClass;
+};
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter];
+export declare const NullsOrder: {
+    readonly first: "first";
+    readonly last: "last";
+};
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder];
+export declare const UserOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly email: "email";
+    readonly name: "name";
+    readonly avatarUrl: "avatarUrl";
+    readonly passwordHash: "passwordHash";
+    readonly totpSecret: "totpSecret";
+    readonly authProvider: "authProvider";
+    readonly invitedById: "invitedById";
+};
+export type UserOrderByRelevanceFieldEnum = (typeof UserOrderByRelevanceFieldEnum)[keyof typeof UserOrderByRelevanceFieldEnum];
+export declare const OAuthAccountOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly provider: "provider";
+    readonly providerAccountId: "providerAccountId";
+    readonly accessToken: "accessToken";
+    readonly refreshToken: "refreshToken";
+};
+export type OAuthAccountOrderByRelevanceFieldEnum = (typeof OAuthAccountOrderByRelevanceFieldEnum)[keyof typeof OAuthAccountOrderByRelevanceFieldEnum];
+export declare const SessionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly token: "token";
+    readonly ipAddress: "ipAddress";
+    readonly userAgent: "userAgent";
+    readonly fingerprintHash: "fingerprintHash";
+};
+export type SessionOrderByRelevanceFieldEnum = (typeof SessionOrderByRelevanceFieldEnum)[keyof typeof SessionOrderByRelevanceFieldEnum];
+export declare const ApiKeyOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly keyHash: "keyHash";
+    readonly keyPrefix: "keyPrefix";
+    readonly userId: "userId";
+};
+export type ApiKeyOrderByRelevanceFieldEnum = (typeof ApiKeyOrderByRelevanceFieldEnum)[keyof typeof ApiKeyOrderByRelevanceFieldEnum];
+export declare const AuditLogOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly event: "event";
+    readonly userId: "userId";
+    readonly ipAddress: "ipAddress";
+    readonly userAgent: "userAgent";
+};
+export type AuditLogOrderByRelevanceFieldEnum = (typeof AuditLogOrderByRelevanceFieldEnum)[keyof typeof AuditLogOrderByRelevanceFieldEnum];
+export declare const FolderOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly scope: "scope";
+    readonly parentId: "parentId";
+};
+export type FolderOrderByRelevanceFieldEnum = (typeof FolderOrderByRelevanceFieldEnum)[keyof typeof FolderOrderByRelevanceFieldEnum];
+export declare const DocumentOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly collection: "collection";
+    readonly title: "title";
+    readonly slug: "slug";
+    readonly locale: "locale";
+    readonly localeGroupId: "localeGroupId";
+    readonly createdById: "createdById";
+    readonly updatedById: "updatedById";
+    readonly plainText: "plainText";
+    readonly contentHash: "contentHash";
+    readonly siteId: "siteId";
+    readonly templateId: "templateId";
+    readonly reviewerId: "reviewerId";
+    readonly reviewNote: "reviewNote";
+    readonly folderId: "folderId";
+};
+export type DocumentOrderByRelevanceFieldEnum = (typeof DocumentOrderByRelevanceFieldEnum)[keyof typeof DocumentOrderByRelevanceFieldEnum];
+export declare const VersionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly changedById: "changedById";
+};
+export type VersionOrderByRelevanceFieldEnum = (typeof VersionOrderByRelevanceFieldEnum)[keyof typeof VersionOrderByRelevanceFieldEnum];
+export declare const MediaOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly filename: "filename";
+    readonly storageKey: "storageKey";
+    readonly mimeType: "mimeType";
+    readonly altText: "altText";
+    readonly title: "title";
+    readonly uploadedById: "uploadedById";
+    readonly blurHash: "blurHash";
+    readonly aiAltText: "aiAltText";
+    readonly aiDescription: "aiDescription";
+    readonly folderId: "folderId";
+    readonly originalFileName: "originalFileName";
+    readonly caption: "caption";
+    readonly description: "description";
+    readonly focusKeyword: "focusKeyword";
+    readonly contentHash: "contentHash";
+    readonly publicUrl: "publicUrl";
+    readonly storageProvider: "storageProvider";
+    readonly thumbnailUrl: "thumbnailUrl";
+};
+export type MediaOrderByRelevanceFieldEnum = (typeof MediaOrderByRelevanceFieldEnum)[keyof typeof MediaOrderByRelevanceFieldEnum];
+export declare const MediaUsageOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly mediaId: "mediaId";
+    readonly documentId: "documentId";
+    readonly fieldPath: "fieldPath";
+};
+export type MediaUsageOrderByRelevanceFieldEnum = (typeof MediaUsageOrderByRelevanceFieldEnum)[keyof typeof MediaUsageOrderByRelevanceFieldEnum];
+export declare const ContentLockOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly userId: "userId";
+};
+export type ContentLockOrderByRelevanceFieldEnum = (typeof ContentLockOrderByRelevanceFieldEnum)[keyof typeof ContentLockOrderByRelevanceFieldEnum];
+export declare const InAppNotificationOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly type: "type";
+    readonly title: "title";
+    readonly message: "message";
+    readonly link: "link";
+};
+export type InAppNotificationOrderByRelevanceFieldEnum = (typeof InAppNotificationOrderByRelevanceFieldEnum)[keyof typeof InAppNotificationOrderByRelevanceFieldEnum];
+export declare const ContentTemplateOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly collection: "collection";
+    readonly createdById: "createdById";
+};
+export type ContentTemplateOrderByRelevanceFieldEnum = (typeof ContentTemplateOrderByRelevanceFieldEnum)[keyof typeof ContentTemplateOrderByRelevanceFieldEnum];
+export declare const SiteOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly domain: "domain";
+    readonly name: "name";
+};
+export type SiteOrderByRelevanceFieldEnum = (typeof SiteOrderByRelevanceFieldEnum)[keyof typeof SiteOrderByRelevanceFieldEnum];
+export declare const WorkflowStateOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly assignedToId: "assignedToId";
+    readonly status: "status";
+};
+export type WorkflowStateOrderByRelevanceFieldEnum = (typeof WorkflowStateOrderByRelevanceFieldEnum)[keyof typeof WorkflowStateOrderByRelevanceFieldEnum];
+export declare const RedirectOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly source: "source";
+    readonly destination: "destination";
+    readonly notes: "notes";
+    readonly source_kind: "source_kind";
+    readonly createdById: "createdById";
+};
+export type RedirectOrderByRelevanceFieldEnum = (typeof RedirectOrderByRelevanceFieldEnum)[keyof typeof RedirectOrderByRelevanceFieldEnum];
+export declare const SeoAuditRunOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly scope: "scope";
+    readonly startedById: "startedById";
+    readonly errorMessage: "errorMessage";
+};
+export type SeoAuditRunOrderByRelevanceFieldEnum = (typeof SeoAuditRunOrderByRelevanceFieldEnum)[keyof typeof SeoAuditRunOrderByRelevanceFieldEnum];
+export declare const SeoIssueOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly auditRunId: "auditRunId";
+    readonly issueKey: "issueKey";
+    readonly entityType: "entityType";
+    readonly entityId: "entityId";
+    readonly entityTitle: "entityTitle";
+    readonly url: "url";
+    readonly type: "type";
+    readonly title: "title";
+    readonly description: "description";
+    readonly impact: "impact";
+    readonly recommendation: "recommendation";
+    readonly fixActionType: "fixActionType";
+    readonly source: "source";
+    readonly resolvedById: "resolvedById";
+};
+export type SeoIssueOrderByRelevanceFieldEnum = (typeof SeoIssueOrderByRelevanceFieldEnum)[keyof typeof SeoIssueOrderByRelevanceFieldEnum];
+export declare const Redirect404HitOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly path: "path";
+    readonly referrer: "referrer";
+};
+export type Redirect404HitOrderByRelevanceFieldEnum = (typeof Redirect404HitOrderByRelevanceFieldEnum)[keyof typeof Redirect404HitOrderByRelevanceFieldEnum];
+export declare const AiCrawlerHitOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly bot: "bot";
+    readonly surface: "surface";
+    readonly category: "category";
+};
+export type AiCrawlerHitOrderByRelevanceFieldEnum = (typeof AiCrawlerHitOrderByRelevanceFieldEnum)[keyof typeof AiCrawlerHitOrderByRelevanceFieldEnum];
+export declare const RedirectSuggestionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly fromPath: "fromPath";
+    readonly toPath: "toPath";
+    readonly reason: "reason";
+    readonly status: "status";
+    readonly source: "source";
+};
+export type RedirectSuggestionOrderByRelevanceFieldEnum = (typeof RedirectSuggestionOrderByRelevanceFieldEnum)[keyof typeof RedirectSuggestionOrderByRelevanceFieldEnum];
+export declare const FormSchemaVersionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly formId: "formId";
+    readonly notes: "notes";
+    readonly createdById: "createdById";
+};
+export type FormSchemaVersionOrderByRelevanceFieldEnum = (typeof FormSchemaVersionOrderByRelevanceFieldEnum)[keyof typeof FormSchemaVersionOrderByRelevanceFieldEnum];
+export declare const FormSubmissionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly formId: "formId";
+    readonly schemaVersionId: "schemaVersionId";
+    readonly senderName: "senderName";
+    readonly senderEmail: "senderEmail";
+    readonly senderPhone: "senderPhone";
+    readonly preview: "preview";
+    readonly status: "status";
+    readonly spamStatus: "spamStatus";
+    readonly ipAddressHash: "ipAddressHash";
+    readonly userAgent: "userAgent";
+    readonly referrer: "referrer";
+    readonly pageUrl: "pageUrl";
+    readonly utmSource: "utmSource";
+    readonly utmMedium: "utmMedium";
+    readonly utmCampaign: "utmCampaign";
+};
+export type FormSubmissionOrderByRelevanceFieldEnum = (typeof FormSubmissionOrderByRelevanceFieldEnum)[keyof typeof FormSubmissionOrderByRelevanceFieldEnum];
+export declare const FormSubmissionFileOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly submissionId: "submissionId";
+    readonly fieldKey: "fieldKey";
+    readonly mediaAssetId: "mediaAssetId";
+    readonly fileName: "fileName";
+    readonly mimeType: "mimeType";
+    readonly storageKey: "storageKey";
+    readonly publicUrl: "publicUrl";
+    readonly secureDownloadUrl: "secureDownloadUrl";
+};
+export type FormSubmissionFileOrderByRelevanceFieldEnum = (typeof FormSubmissionFileOrderByRelevanceFieldEnum)[keyof typeof FormSubmissionFileOrderByRelevanceFieldEnum];
+export declare const FormWebhookOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly formId: "formId";
+    readonly url: "url";
+    readonly secret: "secret";
+    readonly previousSecret: "previousSecret";
+    readonly lastDeliveryStatus: "lastDeliveryStatus";
+};
+export type FormWebhookOrderByRelevanceFieldEnum = (typeof FormWebhookOrderByRelevanceFieldEnum)[keyof typeof FormWebhookOrderByRelevanceFieldEnum];
+export declare const FormDeliveryAttemptOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly submissionId: "submissionId";
+    readonly formId: "formId";
+    readonly channel: "channel";
+    readonly destination: "destination";
+    readonly webhookId: "webhookId";
+    readonly status: "status";
+    readonly error: "error";
+    readonly skippedReason: "skippedReason";
+};
+export type FormDeliveryAttemptOrderByRelevanceFieldEnum = (typeof FormDeliveryAttemptOrderByRelevanceFieldEnum)[keyof typeof FormDeliveryAttemptOrderByRelevanceFieldEnum];
+export declare const BackupRecordOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly filename: "filename";
+    readonly storageKey: "storageKey";
+    readonly type: "type";
+};
+export type BackupRecordOrderByRelevanceFieldEnum = (typeof BackupRecordOrderByRelevanceFieldEnum)[keyof typeof BackupRecordOrderByRelevanceFieldEnum];
+export declare const WebhookEndpointOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly url: "url";
+    readonly secret: "secret";
+    readonly previousSecret: "previousSecret";
+    readonly name: "name";
+};
+export type WebhookEndpointOrderByRelevanceFieldEnum = (typeof WebhookEndpointOrderByRelevanceFieldEnum)[keyof typeof WebhookEndpointOrderByRelevanceFieldEnum];
+export declare const WebhookDeliveryLogOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly endpointId: "endpointId";
+    readonly event: "event";
+    readonly status: "status";
+    readonly responseBody: "responseBody";
+};
+export type WebhookDeliveryLogOrderByRelevanceFieldEnum = (typeof WebhookDeliveryLogOrderByRelevanceFieldEnum)[keyof typeof WebhookDeliveryLogOrderByRelevanceFieldEnum];
+export declare const PasswordResetTokenOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly tokenHash: "tokenHash";
+};
+export type PasswordResetTokenOrderByRelevanceFieldEnum = (typeof PasswordResetTokenOrderByRelevanceFieldEnum)[keyof typeof PasswordResetTokenOrderByRelevanceFieldEnum];
+export declare const InviteOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly email: "email";
+    readonly tokenHash: "tokenHash";
+    readonly message: "message";
+    readonly invitedByUserId: "invitedByUserId";
+    readonly acceptedUserId: "acceptedUserId";
+};
+export type InviteOrderByRelevanceFieldEnum = (typeof InviteOrderByRelevanceFieldEnum)[keyof typeof InviteOrderByRelevanceFieldEnum];
+export declare const ScriptTagOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly code: "code";
+    readonly placement: "placement";
+    readonly scope: "scope";
+    readonly targetPaths: "targetPaths";
+    readonly consentCategory: "consentCategory";
+};
+export type ScriptTagOrderByRelevanceFieldEnum = (typeof ScriptTagOrderByRelevanceFieldEnum)[keyof typeof ScriptTagOrderByRelevanceFieldEnum];
+export declare const PageTemplateOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly description: "description";
+    readonly category: "category";
+    readonly thumbnail: "thumbnail";
+};
+export type PageTemplateOrderByRelevanceFieldEnum = (typeof PageTemplateOrderByRelevanceFieldEnum)[keyof typeof PageTemplateOrderByRelevanceFieldEnum];
+export declare const SavedSectionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly description: "description";
+    readonly category: "category";
+    readonly thumbnail: "thumbnail";
+};
+export type SavedSectionOrderByRelevanceFieldEnum = (typeof SavedSectionOrderByRelevanceFieldEnum)[keyof typeof SavedSectionOrderByRelevanceFieldEnum];
+export declare const ApiRequestMetricOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly route: "route";
+    readonly statusBucket: "statusBucket";
+};
+export type ApiRequestMetricOrderByRelevanceFieldEnum = (typeof ApiRequestMetricOrderByRelevanceFieldEnum)[keyof typeof ApiRequestMetricOrderByRelevanceFieldEnum];
+export declare const ContentIssueOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+};
+export type ContentIssueOrderByRelevanceFieldEnum = (typeof ContentIssueOrderByRelevanceFieldEnum)[keyof typeof ContentIssueOrderByRelevanceFieldEnum];
+/**
+ * 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 'UserRole'
+ */
+export type EnumUserRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserRole'>;
+/**
+ * Reference to a field of type 'UserRole[]'
+ */
+export type ListEnumUserRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserRole[]'>;
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>;
+/**
+ * Reference to a field of type 'Int'
+ */
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
+/**
+ * Reference to a field of type 'Int[]'
+ */
+export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>;
+/**
+ * Reference to a field of type 'Json'
+ */
+export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>;
+/**
+ * Reference to a field of type 'QueryMode'
+ */
+export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>;
+/**
+ * Reference to a field of type 'DateTime'
+ */
+export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>;
+/**
+ * Reference to a field of type 'DateTime[]'
+ */
+export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>;
+/**
+ * Reference to a field of type 'DocumentStatus'
+ */
+export type EnumDocumentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DocumentStatus'>;
+/**
+ * Reference to a field of type 'DocumentStatus[]'
+ */
+export type ListEnumDocumentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DocumentStatus[]'>;
+/**
+ * Reference to a field of type 'WorkflowStage'
+ */
+export type EnumWorkflowStageFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WorkflowStage'>;
+/**
+ * Reference to a field of type 'WorkflowStage[]'
+ */
+export type ListEnumWorkflowStageFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WorkflowStage[]'>;
+/**
+ * Reference to a field of type 'ChangeType'
+ */
+export type EnumChangeTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ChangeType'>;
+/**
+ * Reference to a field of type 'ChangeType[]'
+ */
+export type ListEnumChangeTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ChangeType[]'>;
+/**
+ * Reference to a field of type 'Float'
+ */
+export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>;
+/**
+ * Reference to a field of type 'Float[]'
+ */
+export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>;
+/**
+ * Reference to a field of type 'MediaStatus'
+ */
+export type EnumMediaStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MediaStatus'>;
+/**
+ * Reference to a field of type 'MediaStatus[]'
+ */
+export type ListEnumMediaStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MediaStatus[]'>;
+/**
+ * Reference to a field of type 'SeoAuditStatus'
+ */
+export type EnumSeoAuditStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoAuditStatus'>;
+/**
+ * Reference to a field of type 'SeoAuditStatus[]'
+ */
+export type ListEnumSeoAuditStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoAuditStatus[]'>;
+/**
+ * Reference to a field of type 'SeoIssueSeverity'
+ */
+export type EnumSeoIssueSeverityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoIssueSeverity'>;
+/**
+ * Reference to a field of type 'SeoIssueSeverity[]'
+ */
+export type ListEnumSeoIssueSeverityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoIssueSeverity[]'>;
+/**
+ * Reference to a field of type 'SeoIssueCategory'
+ */
+export type EnumSeoIssueCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoIssueCategory'>;
+/**
+ * Reference to a field of type 'SeoIssueCategory[]'
+ */
+export type ListEnumSeoIssueCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoIssueCategory[]'>;
+/**
+ * Reference to a field of type 'SeoIssueStatus'
+ */
+export type EnumSeoIssueStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoIssueStatus'>;
+/**
+ * Reference to a field of type 'SeoIssueStatus[]'
+ */
+export type ListEnumSeoIssueStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SeoIssueStatus[]'>;
+/**
+ * Reference to a field of type 'InviteStatus'
+ */
+export type EnumInviteStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'InviteStatus'>;
+/**
+ * Reference to a field of type 'InviteStatus[]'
+ */
+export type ListEnumInviteStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'InviteStatus[]'>;
+/**
+ * Reference to a field of type 'ContentIssueType'
+ */
+export type EnumContentIssueTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ContentIssueType'>;
+/**
+ * Reference to a field of type 'ContentIssueType[]'
+ */
+export type ListEnumContentIssueTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ContentIssueType[]'>;
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
+export type BatchPayload = {
+    count: number;
+};
+export declare const defineExtension: runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs>;
+export type DefaultPrismaClient = PrismaClient;
+export type ErrorFormat = 'pretty' | 'colorless' | 'minimal';
+export type PrismaClientOptions = ({
+    /**
+     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+     */
+    adapter: runtime.SqlDriverAdapterFactory;
+    accelerateUrl?: never;
+} | {
+    /**
+     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+     */
+    accelerateUrl: string;
+    adapter?: never;
+}) & {
+    /**
+     * @default "colorless"
+     */
+    errorFormat?: ErrorFormat;
+    /**
+     * @example
+     * ```
+     * // Shorthand for `emit: 'stdout'`
+     * log: ['query', 'info', 'warn', 'error']
+     *
+     * // Emit as events only
+     * log: [
+     *   { emit: 'event', level: 'query' },
+     *   { emit: 'event', level: 'info' },
+     *   { emit: 'event', level: 'warn' }
+     *   { emit: 'event', level: 'error' }
+     * ]
+     *
+     * / Emit as events and log to stdout
+     * og: [
+     *  { emit: 'stdout', level: 'query' },
+     *  { emit: 'stdout', level: 'info' },
+     *  { emit: 'stdout', level: 'warn' }
+     *  { emit: 'stdout', level: 'error' }
+     *
+     * ```
+     * Read more in our [docs](https://pris.ly/d/logging).
+     */
+    log?: (LogLevel | LogDefinition)[];
+    /**
+     * The default values for transactionOptions
+     * maxWait ?= 2000
+     * timeout ?= 5000
+     */
+    transactionOptions?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: TransactionIsolationLevel;
+    };
+    /**
+     * Global configuration for omitting model fields by default.
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   omit: {
+     *     user: {
+     *       password: true
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    omit?: GlobalOmitConfig;
+    /**
+     * SQL commenter plugins that add metadata to SQL queries as comments.
+     * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   adapter,
+     *   comments: [
+     *     traceContext(),
+     *     queryInsights(),
+     *   ],
+     * })
+     * ```
+     */
+    comments?: runtime.SqlCommenterPlugin[];
+    /**
+     * Optional maximum size for the query plan cache. If not provided, a default size will be used.
+     * A value of `0` can be used to disable the cache entirely. A higher cache size can improve
+     * performance for applications that execute a large number of unique queries, while a smaller
+     * cache size can reduce memory usage.
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   adapter,
+     *   queryPlanCacheMaxSize: 100,
+     * })
+     * ```
+     */
+    queryPlanCacheMaxSize?: number;
+};
+export type GlobalOmitConfig = {
+    user?: Prisma.UserOmit;
+    oAuthAccount?: Prisma.OAuthAccountOmit;
+    session?: Prisma.SessionOmit;
+    apiKey?: Prisma.ApiKeyOmit;
+    auditLog?: Prisma.AuditLogOmit;
+    folder?: Prisma.FolderOmit;
+    document?: Prisma.DocumentOmit;
+    version?: Prisma.VersionOmit;
+    media?: Prisma.MediaOmit;
+    mediaUsage?: Prisma.MediaUsageOmit;
+    contentLock?: Prisma.ContentLockOmit;
+    inAppNotification?: Prisma.InAppNotificationOmit;
+    contentTemplate?: Prisma.ContentTemplateOmit;
+    site?: Prisma.SiteOmit;
+    workflowState?: Prisma.WorkflowStateOmit;
+    redirect?: Prisma.RedirectOmit;
+    seoAuditRun?: Prisma.SeoAuditRunOmit;
+    seoIssue?: Prisma.SeoIssueOmit;
+    redirect404Hit?: Prisma.Redirect404HitOmit;
+    aiCrawlerHit?: Prisma.AiCrawlerHitOmit;
+    redirectSuggestion?: Prisma.RedirectSuggestionOmit;
+    formSchemaVersion?: Prisma.FormSchemaVersionOmit;
+    formSubmission?: Prisma.FormSubmissionOmit;
+    formSubmissionFile?: Prisma.FormSubmissionFileOmit;
+    formWebhook?: Prisma.FormWebhookOmit;
+    formDeliveryAttempt?: Prisma.FormDeliveryAttemptOmit;
+    backupRecord?: Prisma.BackupRecordOmit;
+    webhookEndpoint?: Prisma.WebhookEndpointOmit;
+    webhookDeliveryLog?: Prisma.WebhookDeliveryLogOmit;
+    passwordResetToken?: Prisma.PasswordResetTokenOmit;
+    invite?: Prisma.InviteOmit;
+    scriptTag?: Prisma.ScriptTagOmit;
+    pageTemplate?: Prisma.PageTemplateOmit;
+    savedSection?: Prisma.SavedSectionOmit;
+    apiRequestMetric?: Prisma.ApiRequestMetricOmit;
+    contentIssue?: Prisma.ContentIssueOmit;
+};
+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;
+};
+export type PrismaAction = 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'executeRaw' | 'queryRaw' | 'aggregate' | 'count' | 'runCommandRaw' | 'findRaw' | 'groupBy';
+/**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>;