@goscribe/server 1.6.0 → 1.7.0

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

@@ -0,0 +1,3924 @@
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../models";
+import { type PrismaClient } from "./class";
+export type * from '../models';
+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 PasswordResetToken: "PasswordResetToken";
+    readonly Role: "Role";
+    readonly Notification: "Notification";
+    readonly Session: "Session";
+    readonly VerificationToken: "VerificationToken";
+    readonly Folder: "Folder";
+    readonly Workspace: "Workspace";
+    readonly Channel: "Channel";
+    readonly Chat: "Chat";
+    readonly CopilotConversation: "CopilotConversation";
+    readonly CopilotMessage: "CopilotMessage";
+    readonly FileAsset: "FileAsset";
+    readonly Artifact: "Artifact";
+    readonly ArtifactVersion: "ArtifactVersion";
+    readonly StudyGuideHighlight: "StudyGuideHighlight";
+    readonly StudyGuideComment: "StudyGuideComment";
+    readonly Flashcard: "Flashcard";
+    readonly FlashcardProgress: "FlashcardProgress";
+    readonly WorksheetQuestion: "WorksheetQuestion";
+    readonly WorksheetQuestionProgress: "WorksheetQuestionProgress";
+    readonly WorksheetPreset: "WorksheetPreset";
+    readonly WorkspaceMember: "WorkspaceMember";
+    readonly WorkspaceInvitation: "WorkspaceInvitation";
+    readonly PodcastSegment: "PodcastSegment";
+    readonly Invoice: "Invoice";
+    readonly Plan: "Plan";
+    readonly PlanLimit: "PlanLimit";
+    readonly Subscription: "Subscription";
+    readonly ResourcePrice: "ResourcePrice";
+    readonly UserCredit: "UserCredit";
+    readonly IdempotencyRecord: "IdempotencyRecord";
+    readonly StripeEvent: "StripeEvent";
+    readonly ActivityLog: "ActivityLog";
+    readonly KnowledgeBase: "KnowledgeBase";
+    readonly WorkspaceKnowledgeBase: "WorkspaceKnowledgeBase";
+    readonly KnowledgeBaseDocument: "KnowledgeBaseDocument";
+    readonly KnowledgeBaseChunk: "KnowledgeBaseChunk";
+};
+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" | "passwordResetToken" | "role" | "notification" | "session" | "verificationToken" | "folder" | "workspace" | "channel" | "chat" | "copilotConversation" | "copilotMessage" | "fileAsset" | "artifact" | "artifactVersion" | "studyGuideHighlight" | "studyGuideComment" | "flashcard" | "flashcardProgress" | "worksheetQuestion" | "worksheetQuestionProgress" | "worksheetPreset" | "workspaceMember" | "workspaceInvitation" | "podcastSegment" | "invoice" | "plan" | "planLimit" | "subscription" | "resourcePrice" | "userCredit" | "idempotencyRecord" | "stripeEvent" | "activityLog" | "knowledgeBase" | "workspaceKnowledgeBase" | "knowledgeBaseDocument" | "knowledgeBaseChunk";
+        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;
+                };
+            };
+        };
+        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;
+                };
+            };
+        };
+        Role: {
+            payload: Prisma.$RolePayload<ExtArgs>;
+            fields: Prisma.RoleFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.RoleFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.RoleFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>;
+                };
+                findFirst: {
+                    args: Prisma.RoleFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.RoleFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>;
+                };
+                findMany: {
+                    args: Prisma.RoleFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>[];
+                };
+                create: {
+                    args: Prisma.RoleCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>;
+                };
+                createMany: {
+                    args: Prisma.RoleCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.RoleCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>[];
+                };
+                delete: {
+                    args: Prisma.RoleDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>;
+                };
+                update: {
+                    args: Prisma.RoleUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.RoleDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.RoleUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.RoleUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>[];
+                };
+                upsert: {
+                    args: Prisma.RoleUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RolePayload>;
+                };
+                aggregate: {
+                    args: Prisma.RoleAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateRole>;
+                };
+                groupBy: {
+                    args: Prisma.RoleGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RoleGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.RoleCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RoleCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Notification: {
+            payload: Prisma.$NotificationPayload<ExtArgs>;
+            fields: Prisma.NotificationFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.NotificationFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.NotificationFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>;
+                };
+                findFirst: {
+                    args: Prisma.NotificationFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.NotificationFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>;
+                };
+                findMany: {
+                    args: Prisma.NotificationFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>[];
+                };
+                create: {
+                    args: Prisma.NotificationCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>;
+                };
+                createMany: {
+                    args: Prisma.NotificationCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.NotificationCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>[];
+                };
+                delete: {
+                    args: Prisma.NotificationDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>;
+                };
+                update: {
+                    args: Prisma.NotificationUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.NotificationDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.NotificationUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.NotificationUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>[];
+                };
+                upsert: {
+                    args: Prisma.NotificationUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$NotificationPayload>;
+                };
+                aggregate: {
+                    args: Prisma.NotificationAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateNotification>;
+                };
+                groupBy: {
+                    args: Prisma.NotificationGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.NotificationGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.NotificationCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.NotificationCountAggregateOutputType> | 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;
+                };
+            };
+        };
+        VerificationToken: {
+            payload: Prisma.$VerificationTokenPayload<ExtArgs>;
+            fields: Prisma.VerificationTokenFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.VerificationTokenFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.VerificationTokenFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>;
+                };
+                findFirst: {
+                    args: Prisma.VerificationTokenFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.VerificationTokenFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>;
+                };
+                findMany: {
+                    args: Prisma.VerificationTokenFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[];
+                };
+                create: {
+                    args: Prisma.VerificationTokenCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>;
+                };
+                createMany: {
+                    args: Prisma.VerificationTokenCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.VerificationTokenCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[];
+                };
+                delete: {
+                    args: Prisma.VerificationTokenDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>;
+                };
+                update: {
+                    args: Prisma.VerificationTokenUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.VerificationTokenDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.VerificationTokenUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.VerificationTokenUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[];
+                };
+                upsert: {
+                    args: Prisma.VerificationTokenUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>;
+                };
+                aggregate: {
+                    args: Prisma.VerificationTokenAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateVerificationToken>;
+                };
+                groupBy: {
+                    args: Prisma.VerificationTokenGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.VerificationTokenGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.VerificationTokenCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.VerificationTokenCountAggregateOutputType> | 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;
+                };
+            };
+        };
+        Workspace: {
+            payload: Prisma.$WorkspacePayload<ExtArgs>;
+            fields: Prisma.WorkspaceFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkspaceFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkspaceFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkspaceFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkspaceFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkspaceFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>[];
+                };
+                create: {
+                    args: Prisma.WorkspaceCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkspaceCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkspaceCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkspaceDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>;
+                };
+                update: {
+                    args: Prisma.WorkspaceUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkspaceDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkspaceUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkspaceUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkspaceUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspacePayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkspaceAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkspace>;
+                };
+                groupBy: {
+                    args: Prisma.WorkspaceGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkspaceCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Channel: {
+            payload: Prisma.$ChannelPayload<ExtArgs>;
+            fields: Prisma.ChannelFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ChannelFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ChannelFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ChannelFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ChannelFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>;
+                };
+                findMany: {
+                    args: Prisma.ChannelFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>[];
+                };
+                create: {
+                    args: Prisma.ChannelCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>;
+                };
+                createMany: {
+                    args: Prisma.ChannelCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ChannelCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>[];
+                };
+                delete: {
+                    args: Prisma.ChannelDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>;
+                };
+                update: {
+                    args: Prisma.ChannelUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ChannelDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ChannelUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ChannelUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ChannelUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChannelPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ChannelAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateChannel>;
+                };
+                groupBy: {
+                    args: Prisma.ChannelGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ChannelGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ChannelCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ChannelCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Chat: {
+            payload: Prisma.$ChatPayload<ExtArgs>;
+            fields: Prisma.ChatFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ChatFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ChatFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ChatFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ChatFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>;
+                };
+                findMany: {
+                    args: Prisma.ChatFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>[];
+                };
+                create: {
+                    args: Prisma.ChatCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>;
+                };
+                createMany: {
+                    args: Prisma.ChatCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ChatCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>[];
+                };
+                delete: {
+                    args: Prisma.ChatDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>;
+                };
+                update: {
+                    args: Prisma.ChatUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ChatDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ChatUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ChatUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ChatUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ChatPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ChatAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateChat>;
+                };
+                groupBy: {
+                    args: Prisma.ChatGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ChatGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ChatCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ChatCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CopilotConversation: {
+            payload: Prisma.$CopilotConversationPayload<ExtArgs>;
+            fields: Prisma.CopilotConversationFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CopilotConversationFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CopilotConversationFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CopilotConversationFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CopilotConversationFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>;
+                };
+                findMany: {
+                    args: Prisma.CopilotConversationFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>[];
+                };
+                create: {
+                    args: Prisma.CopilotConversationCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>;
+                };
+                createMany: {
+                    args: Prisma.CopilotConversationCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CopilotConversationCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>[];
+                };
+                delete: {
+                    args: Prisma.CopilotConversationDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>;
+                };
+                update: {
+                    args: Prisma.CopilotConversationUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CopilotConversationDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CopilotConversationUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CopilotConversationUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CopilotConversationUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotConversationPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CopilotConversationAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCopilotConversation>;
+                };
+                groupBy: {
+                    args: Prisma.CopilotConversationGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CopilotConversationGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CopilotConversationCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CopilotConversationCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CopilotMessage: {
+            payload: Prisma.$CopilotMessagePayload<ExtArgs>;
+            fields: Prisma.CopilotMessageFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CopilotMessageFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CopilotMessageFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>;
+                };
+                findFirst: {
+                    args: Prisma.CopilotMessageFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CopilotMessageFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>;
+                };
+                findMany: {
+                    args: Prisma.CopilotMessageFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>[];
+                };
+                create: {
+                    args: Prisma.CopilotMessageCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>;
+                };
+                createMany: {
+                    args: Prisma.CopilotMessageCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CopilotMessageCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>[];
+                };
+                delete: {
+                    args: Prisma.CopilotMessageDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>;
+                };
+                update: {
+                    args: Prisma.CopilotMessageUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CopilotMessageDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CopilotMessageUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CopilotMessageUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>[];
+                };
+                upsert: {
+                    args: Prisma.CopilotMessageUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CopilotMessagePayload>;
+                };
+                aggregate: {
+                    args: Prisma.CopilotMessageAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCopilotMessage>;
+                };
+                groupBy: {
+                    args: Prisma.CopilotMessageGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CopilotMessageGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CopilotMessageCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CopilotMessageCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FileAsset: {
+            payload: Prisma.$FileAssetPayload<ExtArgs>;
+            fields: Prisma.FileAssetFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FileAssetFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FileAssetFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FileAssetFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FileAssetFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>;
+                };
+                findMany: {
+                    args: Prisma.FileAssetFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>[];
+                };
+                create: {
+                    args: Prisma.FileAssetCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>;
+                };
+                createMany: {
+                    args: Prisma.FileAssetCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FileAssetCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>[];
+                };
+                delete: {
+                    args: Prisma.FileAssetDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>;
+                };
+                update: {
+                    args: Prisma.FileAssetUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FileAssetDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FileAssetUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FileAssetUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FileAssetUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileAssetPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FileAssetAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFileAsset>;
+                };
+                groupBy: {
+                    args: Prisma.FileAssetGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FileAssetGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FileAssetCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FileAssetCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Artifact: {
+            payload: Prisma.$ArtifactPayload<ExtArgs>;
+            fields: Prisma.ArtifactFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ArtifactFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ArtifactFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ArtifactFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ArtifactFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>;
+                };
+                findMany: {
+                    args: Prisma.ArtifactFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>[];
+                };
+                create: {
+                    args: Prisma.ArtifactCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>;
+                };
+                createMany: {
+                    args: Prisma.ArtifactCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ArtifactCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>[];
+                };
+                delete: {
+                    args: Prisma.ArtifactDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>;
+                };
+                update: {
+                    args: Prisma.ArtifactUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ArtifactDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ArtifactUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ArtifactUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ArtifactUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ArtifactAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateArtifact>;
+                };
+                groupBy: {
+                    args: Prisma.ArtifactGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ArtifactGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ArtifactCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ArtifactCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ArtifactVersion: {
+            payload: Prisma.$ArtifactVersionPayload<ExtArgs>;
+            fields: Prisma.ArtifactVersionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ArtifactVersionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ArtifactVersionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ArtifactVersionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ArtifactVersionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>;
+                };
+                findMany: {
+                    args: Prisma.ArtifactVersionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>[];
+                };
+                create: {
+                    args: Prisma.ArtifactVersionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>;
+                };
+                createMany: {
+                    args: Prisma.ArtifactVersionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ArtifactVersionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>[];
+                };
+                delete: {
+                    args: Prisma.ArtifactVersionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>;
+                };
+                update: {
+                    args: Prisma.ArtifactVersionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ArtifactVersionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ArtifactVersionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ArtifactVersionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ArtifactVersionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ArtifactVersionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ArtifactVersionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateArtifactVersion>;
+                };
+                groupBy: {
+                    args: Prisma.ArtifactVersionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ArtifactVersionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ArtifactVersionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ArtifactVersionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        StudyGuideHighlight: {
+            payload: Prisma.$StudyGuideHighlightPayload<ExtArgs>;
+            fields: Prisma.StudyGuideHighlightFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.StudyGuideHighlightFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.StudyGuideHighlightFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>;
+                };
+                findFirst: {
+                    args: Prisma.StudyGuideHighlightFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.StudyGuideHighlightFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>;
+                };
+                findMany: {
+                    args: Prisma.StudyGuideHighlightFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>[];
+                };
+                create: {
+                    args: Prisma.StudyGuideHighlightCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>;
+                };
+                createMany: {
+                    args: Prisma.StudyGuideHighlightCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.StudyGuideHighlightCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>[];
+                };
+                delete: {
+                    args: Prisma.StudyGuideHighlightDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>;
+                };
+                update: {
+                    args: Prisma.StudyGuideHighlightUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.StudyGuideHighlightDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.StudyGuideHighlightUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.StudyGuideHighlightUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>[];
+                };
+                upsert: {
+                    args: Prisma.StudyGuideHighlightUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideHighlightPayload>;
+                };
+                aggregate: {
+                    args: Prisma.StudyGuideHighlightAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateStudyGuideHighlight>;
+                };
+                groupBy: {
+                    args: Prisma.StudyGuideHighlightGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StudyGuideHighlightGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.StudyGuideHighlightCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StudyGuideHighlightCountAggregateOutputType> | number;
+                };
+            };
+        };
+        StudyGuideComment: {
+            payload: Prisma.$StudyGuideCommentPayload<ExtArgs>;
+            fields: Prisma.StudyGuideCommentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.StudyGuideCommentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.StudyGuideCommentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.StudyGuideCommentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.StudyGuideCommentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>;
+                };
+                findMany: {
+                    args: Prisma.StudyGuideCommentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>[];
+                };
+                create: {
+                    args: Prisma.StudyGuideCommentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>;
+                };
+                createMany: {
+                    args: Prisma.StudyGuideCommentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.StudyGuideCommentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>[];
+                };
+                delete: {
+                    args: Prisma.StudyGuideCommentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>;
+                };
+                update: {
+                    args: Prisma.StudyGuideCommentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.StudyGuideCommentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.StudyGuideCommentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.StudyGuideCommentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.StudyGuideCommentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StudyGuideCommentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.StudyGuideCommentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateStudyGuideComment>;
+                };
+                groupBy: {
+                    args: Prisma.StudyGuideCommentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StudyGuideCommentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.StudyGuideCommentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StudyGuideCommentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Flashcard: {
+            payload: Prisma.$FlashcardPayload<ExtArgs>;
+            fields: Prisma.FlashcardFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FlashcardFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FlashcardFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FlashcardFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FlashcardFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>;
+                };
+                findMany: {
+                    args: Prisma.FlashcardFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>[];
+                };
+                create: {
+                    args: Prisma.FlashcardCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>;
+                };
+                createMany: {
+                    args: Prisma.FlashcardCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FlashcardCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>[];
+                };
+                delete: {
+                    args: Prisma.FlashcardDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>;
+                };
+                update: {
+                    args: Prisma.FlashcardUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FlashcardDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FlashcardUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FlashcardUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FlashcardUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FlashcardAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFlashcard>;
+                };
+                groupBy: {
+                    args: Prisma.FlashcardGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FlashcardGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FlashcardCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FlashcardCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FlashcardProgress: {
+            payload: Prisma.$FlashcardProgressPayload<ExtArgs>;
+            fields: Prisma.FlashcardProgressFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FlashcardProgressFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FlashcardProgressFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FlashcardProgressFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FlashcardProgressFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>;
+                };
+                findMany: {
+                    args: Prisma.FlashcardProgressFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>[];
+                };
+                create: {
+                    args: Prisma.FlashcardProgressCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>;
+                };
+                createMany: {
+                    args: Prisma.FlashcardProgressCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FlashcardProgressCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>[];
+                };
+                delete: {
+                    args: Prisma.FlashcardProgressDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>;
+                };
+                update: {
+                    args: Prisma.FlashcardProgressUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FlashcardProgressDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FlashcardProgressUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FlashcardProgressUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FlashcardProgressUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FlashcardProgressPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FlashcardProgressAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFlashcardProgress>;
+                };
+                groupBy: {
+                    args: Prisma.FlashcardProgressGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FlashcardProgressGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FlashcardProgressCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FlashcardProgressCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorksheetQuestion: {
+            payload: Prisma.$WorksheetQuestionPayload<ExtArgs>;
+            fields: Prisma.WorksheetQuestionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorksheetQuestionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorksheetQuestionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorksheetQuestionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorksheetQuestionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorksheetQuestionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>[];
+                };
+                create: {
+                    args: Prisma.WorksheetQuestionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorksheetQuestionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorksheetQuestionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorksheetQuestionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>;
+                };
+                update: {
+                    args: Prisma.WorksheetQuestionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorksheetQuestionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorksheetQuestionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorksheetQuestionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorksheetQuestionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorksheetQuestionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorksheetQuestion>;
+                };
+                groupBy: {
+                    args: Prisma.WorksheetQuestionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorksheetQuestionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorksheetQuestionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorksheetQuestionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorksheetQuestionProgress: {
+            payload: Prisma.$WorksheetQuestionProgressPayload<ExtArgs>;
+            fields: Prisma.WorksheetQuestionProgressFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorksheetQuestionProgressFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorksheetQuestionProgressFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorksheetQuestionProgressFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorksheetQuestionProgressFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorksheetQuestionProgressFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>[];
+                };
+                create: {
+                    args: Prisma.WorksheetQuestionProgressCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorksheetQuestionProgressCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorksheetQuestionProgressCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorksheetQuestionProgressDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>;
+                };
+                update: {
+                    args: Prisma.WorksheetQuestionProgressUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorksheetQuestionProgressDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorksheetQuestionProgressUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorksheetQuestionProgressUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorksheetQuestionProgressUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetQuestionProgressPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorksheetQuestionProgressAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorksheetQuestionProgress>;
+                };
+                groupBy: {
+                    args: Prisma.WorksheetQuestionProgressGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorksheetQuestionProgressGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorksheetQuestionProgressCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorksheetQuestionProgressCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorksheetPreset: {
+            payload: Prisma.$WorksheetPresetPayload<ExtArgs>;
+            fields: Prisma.WorksheetPresetFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorksheetPresetFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorksheetPresetFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorksheetPresetFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorksheetPresetFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorksheetPresetFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>[];
+                };
+                create: {
+                    args: Prisma.WorksheetPresetCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorksheetPresetCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorksheetPresetCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorksheetPresetDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>;
+                };
+                update: {
+                    args: Prisma.WorksheetPresetUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorksheetPresetDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorksheetPresetUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorksheetPresetUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorksheetPresetUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorksheetPresetPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorksheetPresetAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorksheetPreset>;
+                };
+                groupBy: {
+                    args: Prisma.WorksheetPresetGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorksheetPresetGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorksheetPresetCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorksheetPresetCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkspaceMember: {
+            payload: Prisma.$WorkspaceMemberPayload<ExtArgs>;
+            fields: Prisma.WorkspaceMemberFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkspaceMemberFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkspaceMemberFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkspaceMemberFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkspaceMemberFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkspaceMemberFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>[];
+                };
+                create: {
+                    args: Prisma.WorkspaceMemberCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkspaceMemberCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkspaceMemberCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkspaceMemberDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>;
+                };
+                update: {
+                    args: Prisma.WorkspaceMemberUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkspaceMemberDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkspaceMemberUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkspaceMemberUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkspaceMemberUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceMemberPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkspaceMemberAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkspaceMember>;
+                };
+                groupBy: {
+                    args: Prisma.WorkspaceMemberGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceMemberGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkspaceMemberCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceMemberCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkspaceInvitation: {
+            payload: Prisma.$WorkspaceInvitationPayload<ExtArgs>;
+            fields: Prisma.WorkspaceInvitationFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkspaceInvitationFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkspaceInvitationFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkspaceInvitationFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkspaceInvitationFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkspaceInvitationFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>[];
+                };
+                create: {
+                    args: Prisma.WorkspaceInvitationCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkspaceInvitationCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkspaceInvitationCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkspaceInvitationDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>;
+                };
+                update: {
+                    args: Prisma.WorkspaceInvitationUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkspaceInvitationDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkspaceInvitationUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkspaceInvitationUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkspaceInvitationUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceInvitationPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkspaceInvitationAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkspaceInvitation>;
+                };
+                groupBy: {
+                    args: Prisma.WorkspaceInvitationGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceInvitationGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkspaceInvitationCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceInvitationCountAggregateOutputType> | number;
+                };
+            };
+        };
+        PodcastSegment: {
+            payload: Prisma.$PodcastSegmentPayload<ExtArgs>;
+            fields: Prisma.PodcastSegmentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PodcastSegmentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PodcastSegmentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.PodcastSegmentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PodcastSegmentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>;
+                };
+                findMany: {
+                    args: Prisma.PodcastSegmentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>[];
+                };
+                create: {
+                    args: Prisma.PodcastSegmentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>;
+                };
+                createMany: {
+                    args: Prisma.PodcastSegmentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PodcastSegmentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>[];
+                };
+                delete: {
+                    args: Prisma.PodcastSegmentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>;
+                };
+                update: {
+                    args: Prisma.PodcastSegmentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PodcastSegmentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PodcastSegmentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PodcastSegmentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.PodcastSegmentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PodcastSegmentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.PodcastSegmentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePodcastSegment>;
+                };
+                groupBy: {
+                    args: Prisma.PodcastSegmentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PodcastSegmentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PodcastSegmentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PodcastSegmentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Invoice: {
+            payload: Prisma.$InvoicePayload<ExtArgs>;
+            fields: Prisma.InvoiceFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.InvoiceFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.InvoiceFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>;
+                };
+                findFirst: {
+                    args: Prisma.InvoiceFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.InvoiceFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>;
+                };
+                findMany: {
+                    args: Prisma.InvoiceFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>[];
+                };
+                create: {
+                    args: Prisma.InvoiceCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>;
+                };
+                createMany: {
+                    args: Prisma.InvoiceCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.InvoiceCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>[];
+                };
+                delete: {
+                    args: Prisma.InvoiceDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>;
+                };
+                update: {
+                    args: Prisma.InvoiceUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.InvoiceDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.InvoiceUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.InvoiceUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>[];
+                };
+                upsert: {
+                    args: Prisma.InvoiceUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$InvoicePayload>;
+                };
+                aggregate: {
+                    args: Prisma.InvoiceAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateInvoice>;
+                };
+                groupBy: {
+                    args: Prisma.InvoiceGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.InvoiceGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.InvoiceCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.InvoiceCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Plan: {
+            payload: Prisma.$PlanPayload<ExtArgs>;
+            fields: Prisma.PlanFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PlanFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PlanFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>;
+                };
+                findFirst: {
+                    args: Prisma.PlanFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PlanFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>;
+                };
+                findMany: {
+                    args: Prisma.PlanFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>[];
+                };
+                create: {
+                    args: Prisma.PlanCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>;
+                };
+                createMany: {
+                    args: Prisma.PlanCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PlanCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>[];
+                };
+                delete: {
+                    args: Prisma.PlanDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>;
+                };
+                update: {
+                    args: Prisma.PlanUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PlanDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PlanUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PlanUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>[];
+                };
+                upsert: {
+                    args: Prisma.PlanUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanPayload>;
+                };
+                aggregate: {
+                    args: Prisma.PlanAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePlan>;
+                };
+                groupBy: {
+                    args: Prisma.PlanGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PlanGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PlanCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PlanCountAggregateOutputType> | number;
+                };
+            };
+        };
+        PlanLimit: {
+            payload: Prisma.$PlanLimitPayload<ExtArgs>;
+            fields: Prisma.PlanLimitFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PlanLimitFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PlanLimitFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>;
+                };
+                findFirst: {
+                    args: Prisma.PlanLimitFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PlanLimitFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>;
+                };
+                findMany: {
+                    args: Prisma.PlanLimitFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>[];
+                };
+                create: {
+                    args: Prisma.PlanLimitCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>;
+                };
+                createMany: {
+                    args: Prisma.PlanLimitCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PlanLimitCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>[];
+                };
+                delete: {
+                    args: Prisma.PlanLimitDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>;
+                };
+                update: {
+                    args: Prisma.PlanLimitUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PlanLimitDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PlanLimitUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PlanLimitUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>[];
+                };
+                upsert: {
+                    args: Prisma.PlanLimitUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PlanLimitPayload>;
+                };
+                aggregate: {
+                    args: Prisma.PlanLimitAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePlanLimit>;
+                };
+                groupBy: {
+                    args: Prisma.PlanLimitGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PlanLimitGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PlanLimitCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PlanLimitCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Subscription: {
+            payload: Prisma.$SubscriptionPayload<ExtArgs>;
+            fields: Prisma.SubscriptionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SubscriptionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SubscriptionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SubscriptionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SubscriptionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>;
+                };
+                findMany: {
+                    args: Prisma.SubscriptionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>[];
+                };
+                create: {
+                    args: Prisma.SubscriptionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>;
+                };
+                createMany: {
+                    args: Prisma.SubscriptionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SubscriptionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>[];
+                };
+                delete: {
+                    args: Prisma.SubscriptionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>;
+                };
+                update: {
+                    args: Prisma.SubscriptionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SubscriptionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SubscriptionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SubscriptionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SubscriptionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SubscriptionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SubscriptionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSubscription>;
+                };
+                groupBy: {
+                    args: Prisma.SubscriptionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SubscriptionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SubscriptionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SubscriptionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ResourcePrice: {
+            payload: Prisma.$ResourcePricePayload<ExtArgs>;
+            fields: Prisma.ResourcePriceFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ResourcePriceFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ResourcePriceFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ResourcePriceFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ResourcePriceFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>;
+                };
+                findMany: {
+                    args: Prisma.ResourcePriceFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>[];
+                };
+                create: {
+                    args: Prisma.ResourcePriceCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>;
+                };
+                createMany: {
+                    args: Prisma.ResourcePriceCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ResourcePriceCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>[];
+                };
+                delete: {
+                    args: Prisma.ResourcePriceDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>;
+                };
+                update: {
+                    args: Prisma.ResourcePriceUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ResourcePriceDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ResourcePriceUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ResourcePriceUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ResourcePriceUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ResourcePricePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ResourcePriceAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateResourcePrice>;
+                };
+                groupBy: {
+                    args: Prisma.ResourcePriceGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ResourcePriceGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ResourcePriceCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ResourcePriceCountAggregateOutputType> | number;
+                };
+            };
+        };
+        UserCredit: {
+            payload: Prisma.$UserCreditPayload<ExtArgs>;
+            fields: Prisma.UserCreditFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.UserCreditFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.UserCreditFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>;
+                };
+                findFirst: {
+                    args: Prisma.UserCreditFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.UserCreditFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>;
+                };
+                findMany: {
+                    args: Prisma.UserCreditFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>[];
+                };
+                create: {
+                    args: Prisma.UserCreditCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>;
+                };
+                createMany: {
+                    args: Prisma.UserCreditCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.UserCreditCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>[];
+                };
+                delete: {
+                    args: Prisma.UserCreditDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>;
+                };
+                update: {
+                    args: Prisma.UserCreditUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.UserCreditDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.UserCreditUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.UserCreditUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>[];
+                };
+                upsert: {
+                    args: Prisma.UserCreditUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserCreditPayload>;
+                };
+                aggregate: {
+                    args: Prisma.UserCreditAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateUserCredit>;
+                };
+                groupBy: {
+                    args: Prisma.UserCreditGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserCreditGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.UserCreditCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserCreditCountAggregateOutputType> | number;
+                };
+            };
+        };
+        IdempotencyRecord: {
+            payload: Prisma.$IdempotencyRecordPayload<ExtArgs>;
+            fields: Prisma.IdempotencyRecordFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.IdempotencyRecordFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.IdempotencyRecordFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>;
+                };
+                findFirst: {
+                    args: Prisma.IdempotencyRecordFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.IdempotencyRecordFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>;
+                };
+                findMany: {
+                    args: Prisma.IdempotencyRecordFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>[];
+                };
+                create: {
+                    args: Prisma.IdempotencyRecordCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>;
+                };
+                createMany: {
+                    args: Prisma.IdempotencyRecordCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.IdempotencyRecordCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>[];
+                };
+                delete: {
+                    args: Prisma.IdempotencyRecordDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>;
+                };
+                update: {
+                    args: Prisma.IdempotencyRecordUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.IdempotencyRecordDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.IdempotencyRecordUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.IdempotencyRecordUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>[];
+                };
+                upsert: {
+                    args: Prisma.IdempotencyRecordUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$IdempotencyRecordPayload>;
+                };
+                aggregate: {
+                    args: Prisma.IdempotencyRecordAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateIdempotencyRecord>;
+                };
+                groupBy: {
+                    args: Prisma.IdempotencyRecordGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.IdempotencyRecordGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.IdempotencyRecordCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.IdempotencyRecordCountAggregateOutputType> | number;
+                };
+            };
+        };
+        StripeEvent: {
+            payload: Prisma.$StripeEventPayload<ExtArgs>;
+            fields: Prisma.StripeEventFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.StripeEventFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.StripeEventFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>;
+                };
+                findFirst: {
+                    args: Prisma.StripeEventFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.StripeEventFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>;
+                };
+                findMany: {
+                    args: Prisma.StripeEventFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>[];
+                };
+                create: {
+                    args: Prisma.StripeEventCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>;
+                };
+                createMany: {
+                    args: Prisma.StripeEventCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.StripeEventCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>[];
+                };
+                delete: {
+                    args: Prisma.StripeEventDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>;
+                };
+                update: {
+                    args: Prisma.StripeEventUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.StripeEventDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.StripeEventUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.StripeEventUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>[];
+                };
+                upsert: {
+                    args: Prisma.StripeEventUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StripeEventPayload>;
+                };
+                aggregate: {
+                    args: Prisma.StripeEventAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateStripeEvent>;
+                };
+                groupBy: {
+                    args: Prisma.StripeEventGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StripeEventGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.StripeEventCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StripeEventCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ActivityLog: {
+            payload: Prisma.$ActivityLogPayload<ExtArgs>;
+            fields: Prisma.ActivityLogFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ActivityLogFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ActivityLogFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ActivityLogFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ActivityLogFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>;
+                };
+                findMany: {
+                    args: Prisma.ActivityLogFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>[];
+                };
+                create: {
+                    args: Prisma.ActivityLogCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>;
+                };
+                createMany: {
+                    args: Prisma.ActivityLogCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ActivityLogCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>[];
+                };
+                delete: {
+                    args: Prisma.ActivityLogDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>;
+                };
+                update: {
+                    args: Prisma.ActivityLogUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ActivityLogDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ActivityLogUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ActivityLogUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ActivityLogUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ActivityLogPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ActivityLogAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateActivityLog>;
+                };
+                groupBy: {
+                    args: Prisma.ActivityLogGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ActivityLogGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ActivityLogCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ActivityLogCountAggregateOutputType> | number;
+                };
+            };
+        };
+        KnowledgeBase: {
+            payload: Prisma.$KnowledgeBasePayload<ExtArgs>;
+            fields: Prisma.KnowledgeBaseFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.KnowledgeBaseFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.KnowledgeBaseFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>;
+                };
+                findFirst: {
+                    args: Prisma.KnowledgeBaseFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.KnowledgeBaseFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>;
+                };
+                findMany: {
+                    args: Prisma.KnowledgeBaseFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>[];
+                };
+                create: {
+                    args: Prisma.KnowledgeBaseCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>;
+                };
+                createMany: {
+                    args: Prisma.KnowledgeBaseCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.KnowledgeBaseCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>[];
+                };
+                delete: {
+                    args: Prisma.KnowledgeBaseDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>;
+                };
+                update: {
+                    args: Prisma.KnowledgeBaseUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.KnowledgeBaseDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.KnowledgeBaseUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.KnowledgeBaseUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>[];
+                };
+                upsert: {
+                    args: Prisma.KnowledgeBaseUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBasePayload>;
+                };
+                aggregate: {
+                    args: Prisma.KnowledgeBaseAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateKnowledgeBase>;
+                };
+                groupBy: {
+                    args: Prisma.KnowledgeBaseGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.KnowledgeBaseGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.KnowledgeBaseCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.KnowledgeBaseCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkspaceKnowledgeBase: {
+            payload: Prisma.$WorkspaceKnowledgeBasePayload<ExtArgs>;
+            fields: Prisma.WorkspaceKnowledgeBaseFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkspaceKnowledgeBaseFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkspaceKnowledgeBaseFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkspaceKnowledgeBaseFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkspaceKnowledgeBaseFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkspaceKnowledgeBaseFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>[];
+                };
+                create: {
+                    args: Prisma.WorkspaceKnowledgeBaseCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkspaceKnowledgeBaseCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkspaceKnowledgeBaseCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkspaceKnowledgeBaseDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>;
+                };
+                update: {
+                    args: Prisma.WorkspaceKnowledgeBaseUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkspaceKnowledgeBaseDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkspaceKnowledgeBaseUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkspaceKnowledgeBaseUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkspaceKnowledgeBaseUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkspaceKnowledgeBasePayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkspaceKnowledgeBaseAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkspaceKnowledgeBase>;
+                };
+                groupBy: {
+                    args: Prisma.WorkspaceKnowledgeBaseGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceKnowledgeBaseGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkspaceKnowledgeBaseCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkspaceKnowledgeBaseCountAggregateOutputType> | number;
+                };
+            };
+        };
+        KnowledgeBaseDocument: {
+            payload: Prisma.$KnowledgeBaseDocumentPayload<ExtArgs>;
+            fields: Prisma.KnowledgeBaseDocumentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.KnowledgeBaseDocumentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.KnowledgeBaseDocumentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.KnowledgeBaseDocumentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.KnowledgeBaseDocumentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>;
+                };
+                findMany: {
+                    args: Prisma.KnowledgeBaseDocumentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>[];
+                };
+                create: {
+                    args: Prisma.KnowledgeBaseDocumentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>;
+                };
+                createMany: {
+                    args: Prisma.KnowledgeBaseDocumentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.KnowledgeBaseDocumentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>[];
+                };
+                delete: {
+                    args: Prisma.KnowledgeBaseDocumentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>;
+                };
+                update: {
+                    args: Prisma.KnowledgeBaseDocumentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.KnowledgeBaseDocumentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.KnowledgeBaseDocumentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.KnowledgeBaseDocumentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.KnowledgeBaseDocumentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseDocumentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.KnowledgeBaseDocumentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateKnowledgeBaseDocument>;
+                };
+                groupBy: {
+                    args: Prisma.KnowledgeBaseDocumentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.KnowledgeBaseDocumentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.KnowledgeBaseDocumentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.KnowledgeBaseDocumentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        KnowledgeBaseChunk: {
+            payload: Prisma.$KnowledgeBaseChunkPayload<ExtArgs>;
+            fields: Prisma.KnowledgeBaseChunkFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.KnowledgeBaseChunkFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.KnowledgeBaseChunkFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>;
+                };
+                findFirst: {
+                    args: Prisma.KnowledgeBaseChunkFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.KnowledgeBaseChunkFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>;
+                };
+                findMany: {
+                    args: Prisma.KnowledgeBaseChunkFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>[];
+                };
+                create: {
+                    args: Prisma.KnowledgeBaseChunkCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>;
+                };
+                createMany: {
+                    args: Prisma.KnowledgeBaseChunkCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.KnowledgeBaseChunkCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>[];
+                };
+                delete: {
+                    args: Prisma.KnowledgeBaseChunkDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>;
+                };
+                update: {
+                    args: Prisma.KnowledgeBaseChunkUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.KnowledgeBaseChunkDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.KnowledgeBaseChunkUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.KnowledgeBaseChunkUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>[];
+                };
+                upsert: {
+                    args: Prisma.KnowledgeBaseChunkUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$KnowledgeBaseChunkPayload>;
+                };
+                aggregate: {
+                    args: Prisma.KnowledgeBaseChunkAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateKnowledgeBaseChunk>;
+                };
+                groupBy: {
+                    args: Prisma.KnowledgeBaseChunkGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.KnowledgeBaseChunkGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.KnowledgeBaseChunkCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.KnowledgeBaseChunkCountAggregateOutputType> | 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 name: "name";
+    readonly email: "email";
+    readonly emailVerified: "emailVerified";
+    readonly passwordHash: "passwordHash";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly fileAssetId: "fileAssetId";
+    readonly roleId: "roleId";
+    readonly deletedAt: "deletedAt";
+    readonly stripe_customer_id: "stripe_customer_id";
+};
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum];
+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 RoleScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+};
+export type RoleScalarFieldEnum = (typeof RoleScalarFieldEnum)[keyof typeof RoleScalarFieldEnum];
+export declare const NotificationScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly actorUserId: "actorUserId";
+    readonly workspaceId: "workspaceId";
+    readonly type: "type";
+    readonly title: "title";
+    readonly body: "body";
+    readonly content: "content";
+    readonly actionUrl: "actionUrl";
+    readonly metadata: "metadata";
+    readonly priority: "priority";
+    readonly sourceId: "sourceId";
+    readonly read: "read";
+    readonly readAt: "readAt";
+    readonly deliveredAt: "deliveredAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type NotificationScalarFieldEnum = (typeof NotificationScalarFieldEnum)[keyof typeof NotificationScalarFieldEnum];
+export declare const SessionScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly expires: "expires";
+};
+export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum];
+export declare const VerificationTokenScalarFieldEnum: {
+    readonly identifier: "identifier";
+    readonly token: "token";
+    readonly expires: "expires";
+};
+export type VerificationTokenScalarFieldEnum = (typeof VerificationTokenScalarFieldEnum)[keyof typeof VerificationTokenScalarFieldEnum];
+export declare const FolderScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly ownerId: "ownerId";
+    readonly parentId: "parentId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly color: "color";
+    readonly markerColor: "markerColor";
+};
+export type FolderScalarFieldEnum = (typeof FolderScalarFieldEnum)[keyof typeof FolderScalarFieldEnum];
+export declare const WorkspaceScalarFieldEnum: {
+    readonly id: "id";
+    readonly title: "title";
+    readonly description: "description";
+    readonly ownerId: "ownerId";
+    readonly icon: "icon";
+    readonly color: "color";
+    readonly markerColor: "markerColor";
+    readonly folderId: "folderId";
+    readonly fileBeingAnalyzed: "fileBeingAnalyzed";
+    readonly analysisProgress: "analysisProgress";
+    readonly needsAnalysis: "needsAnalysis";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type WorkspaceScalarFieldEnum = (typeof WorkspaceScalarFieldEnum)[keyof typeof WorkspaceScalarFieldEnum];
+export declare const ChannelScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly name: "name";
+    readonly createdAt: "createdAt";
+};
+export type ChannelScalarFieldEnum = (typeof ChannelScalarFieldEnum)[keyof typeof ChannelScalarFieldEnum];
+export declare const ChatScalarFieldEnum: {
+    readonly id: "id";
+    readonly channelId: "channelId";
+    readonly userId: "userId";
+    readonly message: "message";
+    readonly updatedAt: "updatedAt";
+    readonly createdAt: "createdAt";
+};
+export type ChatScalarFieldEnum = (typeof ChatScalarFieldEnum)[keyof typeof ChatScalarFieldEnum];
+export declare const CopilotConversationScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly userId: "userId";
+    readonly title: "title";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type CopilotConversationScalarFieldEnum = (typeof CopilotConversationScalarFieldEnum)[keyof typeof CopilotConversationScalarFieldEnum];
+export declare const CopilotMessageScalarFieldEnum: {
+    readonly id: "id";
+    readonly conversationId: "conversationId";
+    readonly role: "role";
+    readonly content: "content";
+    readonly createdAt: "createdAt";
+};
+export type CopilotMessageScalarFieldEnum = (typeof CopilotMessageScalarFieldEnum)[keyof typeof CopilotMessageScalarFieldEnum];
+export declare const FileAssetScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly userId: "userId";
+    readonly name: "name";
+    readonly mimeType: "mimeType";
+    readonly size: "size";
+    readonly bucket: "bucket";
+    readonly objectKey: "objectKey";
+    readonly url: "url";
+    readonly checksum: "checksum";
+    readonly meta: "meta";
+    readonly createdAt: "createdAt";
+    readonly aiTranscription: "aiTranscription";
+};
+export type FileAssetScalarFieldEnum = (typeof FileAssetScalarFieldEnum)[keyof typeof FileAssetScalarFieldEnum];
+export declare const ArtifactScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly type: "type";
+    readonly title: "title";
+    readonly isArchived: "isArchived";
+    readonly difficulty: "difficulty";
+    readonly estimatedTime: "estimatedTime";
+    readonly createdById: "createdById";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly description: "description";
+    readonly generating: "generating";
+    readonly generatingMetadata: "generatingMetadata";
+    readonly worksheetConfig: "worksheetConfig";
+    readonly imageObjectKey: "imageObjectKey";
+};
+export type ArtifactScalarFieldEnum = (typeof ArtifactScalarFieldEnum)[keyof typeof ArtifactScalarFieldEnum];
+export declare const ArtifactVersionScalarFieldEnum: {
+    readonly id: "id";
+    readonly artifactId: "artifactId";
+    readonly content: "content";
+    readonly data: "data";
+    readonly version: "version";
+    readonly createdById: "createdById";
+    readonly createdAt: "createdAt";
+};
+export type ArtifactVersionScalarFieldEnum = (typeof ArtifactVersionScalarFieldEnum)[keyof typeof ArtifactVersionScalarFieldEnum];
+export declare const StudyGuideHighlightScalarFieldEnum: {
+    readonly id: "id";
+    readonly artifactVersionId: "artifactVersionId";
+    readonly userId: "userId";
+    readonly startOffset: "startOffset";
+    readonly endOffset: "endOffset";
+    readonly selectedText: "selectedText";
+    readonly color: "color";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type StudyGuideHighlightScalarFieldEnum = (typeof StudyGuideHighlightScalarFieldEnum)[keyof typeof StudyGuideHighlightScalarFieldEnum];
+export declare const StudyGuideCommentScalarFieldEnum: {
+    readonly id: "id";
+    readonly highlightId: "highlightId";
+    readonly userId: "userId";
+    readonly content: "content";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type StudyGuideCommentScalarFieldEnum = (typeof StudyGuideCommentScalarFieldEnum)[keyof typeof StudyGuideCommentScalarFieldEnum];
+export declare const FlashcardScalarFieldEnum: {
+    readonly id: "id";
+    readonly artifactId: "artifactId";
+    readonly front: "front";
+    readonly back: "back";
+    readonly tags: "tags";
+    readonly order: "order";
+    readonly createdAt: "createdAt";
+    readonly acceptedAnswers: "acceptedAnswers";
+};
+export type FlashcardScalarFieldEnum = (typeof FlashcardScalarFieldEnum)[keyof typeof FlashcardScalarFieldEnum];
+export declare const FlashcardProgressScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly flashcardId: "flashcardId";
+    readonly timesStudied: "timesStudied";
+    readonly timesCorrect: "timesCorrect";
+    readonly timesIncorrect: "timesIncorrect";
+    readonly timesIncorrectConsecutive: "timesIncorrectConsecutive";
+    readonly easeFactor: "easeFactor";
+    readonly interval: "interval";
+    readonly repetitions: "repetitions";
+    readonly masteryLevel: "masteryLevel";
+    readonly lastStudiedAt: "lastStudiedAt";
+    readonly nextReviewAt: "nextReviewAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type FlashcardProgressScalarFieldEnum = (typeof FlashcardProgressScalarFieldEnum)[keyof typeof FlashcardProgressScalarFieldEnum];
+export declare const WorksheetQuestionScalarFieldEnum: {
+    readonly id: "id";
+    readonly artifactId: "artifactId";
+    readonly prompt: "prompt";
+    readonly answer: "answer";
+    readonly type: "type";
+    readonly difficulty: "difficulty";
+    readonly order: "order";
+    readonly meta: "meta";
+    readonly createdAt: "createdAt";
+};
+export type WorksheetQuestionScalarFieldEnum = (typeof WorksheetQuestionScalarFieldEnum)[keyof typeof WorksheetQuestionScalarFieldEnum];
+export declare const WorksheetQuestionProgressScalarFieldEnum: {
+    readonly id: "id";
+    readonly worksheetQuestionId: "worksheetQuestionId";
+    readonly userId: "userId";
+    readonly userAnswer: "userAnswer";
+    readonly completedAt: "completedAt";
+    readonly attempts: "attempts";
+    readonly timeSpentSec: "timeSpentSec";
+    readonly meta: "meta";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly correct: "correct";
+    readonly modified: "modified";
+};
+export type WorksheetQuestionProgressScalarFieldEnum = (typeof WorksheetQuestionProgressScalarFieldEnum)[keyof typeof WorksheetQuestionProgressScalarFieldEnum];
+export declare const WorksheetPresetScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly workspaceId: "workspaceId";
+    readonly name: "name";
+    readonly isSystem: "isSystem";
+    readonly config: "config";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type WorksheetPresetScalarFieldEnum = (typeof WorksheetPresetScalarFieldEnum)[keyof typeof WorksheetPresetScalarFieldEnum];
+export declare const WorkspaceMemberScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly userId: "userId";
+    readonly role: "role";
+    readonly joinedAt: "joinedAt";
+    readonly updatedAt: "updatedAt";
+};
+export type WorkspaceMemberScalarFieldEnum = (typeof WorkspaceMemberScalarFieldEnum)[keyof typeof WorkspaceMemberScalarFieldEnum];
+export declare const WorkspaceInvitationScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly email: "email";
+    readonly role: "role";
+    readonly token: "token";
+    readonly invitedById: "invitedById";
+    readonly acceptedAt: "acceptedAt";
+    readonly expiresAt: "expiresAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type WorkspaceInvitationScalarFieldEnum = (typeof WorkspaceInvitationScalarFieldEnum)[keyof typeof WorkspaceInvitationScalarFieldEnum];
+export declare const PodcastSegmentScalarFieldEnum: {
+    readonly id: "id";
+    readonly artifactId: "artifactId";
+    readonly title: "title";
+    readonly content: "content";
+    readonly startTime: "startTime";
+    readonly duration: "duration";
+    readonly order: "order";
+    readonly objectKey: "objectKey";
+    readonly audioUrl: "audioUrl";
+    readonly keyPoints: "keyPoints";
+    readonly meta: "meta";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly generating: "generating";
+    readonly generatingMetadata: "generatingMetadata";
+};
+export type PodcastSegmentScalarFieldEnum = (typeof PodcastSegmentScalarFieldEnum)[keyof typeof PodcastSegmentScalarFieldEnum];
+export declare const InvoiceScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly subscriptionId: "subscriptionId";
+    readonly stripeInvoiceId: "stripeInvoiceId";
+    readonly amountPaid: "amountPaid";
+    readonly status: "status";
+    readonly invoicePdfUrl: "invoicePdfUrl";
+    readonly hostedInvoiceUrl: "hostedInvoiceUrl";
+    readonly paidAt: "paidAt";
+    readonly type: "type";
+    readonly createdAt: "createdAt";
+};
+export type InvoiceScalarFieldEnum = (typeof InvoiceScalarFieldEnum)[keyof typeof InvoiceScalarFieldEnum];
+export declare const PlanScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly description: "description";
+    readonly type: "type";
+    readonly price: "price";
+    readonly stripePriceId: "stripePriceId";
+    readonly interval: "interval";
+    readonly active: "active";
+    readonly createdAt: "createdAt";
+};
+export type PlanScalarFieldEnum = (typeof PlanScalarFieldEnum)[keyof typeof PlanScalarFieldEnum];
+export declare const PlanLimitScalarFieldEnum: {
+    readonly id: "id";
+    readonly planId: "planId";
+    readonly maxStorageBytes: "maxStorageBytes";
+    readonly maxWorksheets: "maxWorksheets";
+    readonly maxFlashcards: "maxFlashcards";
+    readonly maxPodcasts: "maxPodcasts";
+    readonly maxStudyGuides: "maxStudyGuides";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type PlanLimitScalarFieldEnum = (typeof PlanLimitScalarFieldEnum)[keyof typeof PlanLimitScalarFieldEnum];
+export declare const SubscriptionScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly planId: "planId";
+    readonly stripeSubscriptionId: "stripeSubscriptionId";
+    readonly stripeCustomerId: "stripeCustomerId";
+    readonly status: "status";
+    readonly currentPeriodStart: "currentPeriodStart";
+    readonly currentPeriodEnd: "currentPeriodEnd";
+    readonly cancelAt: "cancelAt";
+    readonly canceledAt: "canceledAt";
+    readonly createdAt: "createdAt";
+};
+export type SubscriptionScalarFieldEnum = (typeof SubscriptionScalarFieldEnum)[keyof typeof SubscriptionScalarFieldEnum];
+export declare const ResourcePriceScalarFieldEnum: {
+    readonly id: "id";
+    readonly resourceType: "resourceType";
+    readonly priceCents: "priceCents";
+    readonly updatedAt: "updatedAt";
+};
+export type ResourcePriceScalarFieldEnum = (typeof ResourcePriceScalarFieldEnum)[keyof typeof ResourcePriceScalarFieldEnum];
+export declare const UserCreditScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly resourceType: "resourceType";
+    readonly amount: "amount";
+    readonly stripeSessionId: "stripeSessionId";
+    readonly createdAt: "createdAt";
+};
+export type UserCreditScalarFieldEnum = (typeof UserCreditScalarFieldEnum)[keyof typeof UserCreditScalarFieldEnum];
+export declare const IdempotencyRecordScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly planId: "planId";
+    readonly resourceType: "resourceType";
+    readonly stripeSessionId: "stripeSessionId";
+    readonly status: "status";
+    readonly activeLockKey: "activeLockKey";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type IdempotencyRecordScalarFieldEnum = (typeof IdempotencyRecordScalarFieldEnum)[keyof typeof IdempotencyRecordScalarFieldEnum];
+export declare const StripeEventScalarFieldEnum: {
+    readonly id: "id";
+    readonly stripeEventId: "stripeEventId";
+    readonly type: "type";
+    readonly status: "status";
+    readonly error: "error";
+    readonly processedAt: "processedAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type StripeEventScalarFieldEnum = (typeof StripeEventScalarFieldEnum)[keyof typeof StripeEventScalarFieldEnum];
+export declare const ActivityLogScalarFieldEnum: {
+    readonly id: "id";
+    readonly createdAt: "createdAt";
+    readonly actorUserId: "actorUserId";
+    readonly actorEmailSnapshot: "actorEmailSnapshot";
+    readonly action: "action";
+    readonly category: "category";
+    readonly resourceType: "resourceType";
+    readonly resourceId: "resourceId";
+    readonly workspaceId: "workspaceId";
+    readonly trpcPath: "trpcPath";
+    readonly httpMethod: "httpMethod";
+    readonly status: "status";
+    readonly errorCode: "errorCode";
+    readonly durationMs: "durationMs";
+    readonly ipAddress: "ipAddress";
+    readonly userAgent: "userAgent";
+    readonly metadata: "metadata";
+};
+export type ActivityLogScalarFieldEnum = (typeof ActivityLogScalarFieldEnum)[keyof typeof ActivityLogScalarFieldEnum];
+export declare const KnowledgeBaseScalarFieldEnum: {
+    readonly id: "id";
+    readonly createdById: "createdById";
+    readonly name: "name";
+    readonly description: "description";
+    readonly isCurated: "isCurated";
+    readonly status: "status";
+    readonly embeddingModel: "embeddingModel";
+    readonly embeddingDim: "embeddingDim";
+    readonly meta: "meta";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type KnowledgeBaseScalarFieldEnum = (typeof KnowledgeBaseScalarFieldEnum)[keyof typeof KnowledgeBaseScalarFieldEnum];
+export declare const WorkspaceKnowledgeBaseScalarFieldEnum: {
+    readonly id: "id";
+    readonly workspaceId: "workspaceId";
+    readonly knowledgeBaseId: "knowledgeBaseId";
+    readonly addedById: "addedById";
+    readonly createdAt: "createdAt";
+};
+export type WorkspaceKnowledgeBaseScalarFieldEnum = (typeof WorkspaceKnowledgeBaseScalarFieldEnum)[keyof typeof WorkspaceKnowledgeBaseScalarFieldEnum];
+export declare const KnowledgeBaseDocumentScalarFieldEnum: {
+    readonly id: "id";
+    readonly knowledgeBaseId: "knowledgeBaseId";
+    readonly name: "name";
+    readonly mimeType: "mimeType";
+    readonly size: "size";
+    readonly bucket: "bucket";
+    readonly objectKey: "objectKey";
+    readonly status: "status";
+    readonly errorMessage: "errorMessage";
+    readonly numChunks: "numChunks";
+    readonly numPages: "numPages";
+    readonly meta: "meta";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type KnowledgeBaseDocumentScalarFieldEnum = (typeof KnowledgeBaseDocumentScalarFieldEnum)[keyof typeof KnowledgeBaseDocumentScalarFieldEnum];
+export declare const KnowledgeBaseChunkScalarFieldEnum: {
+    readonly id: "id";
+    readonly documentId: "documentId";
+    readonly knowledgeBaseId: "knowledgeBaseId";
+    readonly chunkIndex: "chunkIndex";
+    readonly pageNumber: "pageNumber";
+    readonly content: "content";
+    readonly tokenCount: "tokenCount";
+    readonly createdAt: "createdAt";
+};
+export type KnowledgeBaseChunkScalarFieldEnum = (typeof KnowledgeBaseChunkScalarFieldEnum)[keyof typeof KnowledgeBaseChunkScalarFieldEnum];
+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 NullsOrder: {
+    readonly first: "first";
+    readonly last: "last";
+};
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder];
+export declare const JsonNullValueFilter: {
+    readonly DbNull: runtime.DbNullClass;
+    readonly JsonNull: runtime.JsonNullClass;
+    readonly AnyNull: runtime.AnyNullClass;
+};
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter];
+/**
+ * Field references
+ */
+/**
+ * Reference to a field of type 'String'
+ */
+export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>;
+/**
+ * Reference to a field of type 'String[]'
+ */
+export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>;
+/**
+ * Reference to a field of type 'DateTime'
+ */
+export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>;
+/**
+ * Reference to a field of type 'DateTime[]'
+ */
+export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>;
+/**
+ * Reference to a field of type '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 'NotificationPriority'
+ */
+export type EnumNotificationPriorityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'NotificationPriority'>;
+/**
+ * Reference to a field of type 'NotificationPriority[]'
+ */
+export type ListEnumNotificationPriorityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'NotificationPriority[]'>;
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>;
+/**
+ * Reference to a field of type 'CopilotMessageRole'
+ */
+export type EnumCopilotMessageRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CopilotMessageRole'>;
+/**
+ * Reference to a field of type 'CopilotMessageRole[]'
+ */
+export type ListEnumCopilotMessageRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CopilotMessageRole[]'>;
+/**
+ * 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 'ArtifactType'
+ */
+export type EnumArtifactTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ArtifactType'>;
+/**
+ * Reference to a field of type 'ArtifactType[]'
+ */
+export type ListEnumArtifactTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ArtifactType[]'>;
+/**
+ * Reference to a field of type 'Difficulty'
+ */
+export type EnumDifficultyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Difficulty'>;
+/**
+ * Reference to a field of type 'Difficulty[]'
+ */
+export type ListEnumDifficultyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Difficulty[]'>;
+/**
+ * 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 'QuestionType'
+ */
+export type EnumQuestionTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QuestionType'>;
+/**
+ * Reference to a field of type 'QuestionType[]'
+ */
+export type ListEnumQuestionTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QuestionType[]'>;
+/**
+ * Reference to a field of type 'InvoiceType'
+ */
+export type EnumInvoiceTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'InvoiceType'>;
+/**
+ * Reference to a field of type 'InvoiceType[]'
+ */
+export type ListEnumInvoiceTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'InvoiceType[]'>;
+/**
+ * Reference to a field of type 'BigInt'
+ */
+export type BigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt'>;
+/**
+ * Reference to a field of type 'BigInt[]'
+ */
+export type ListBigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt[]'>;
+/**
+ * Reference to a field of type 'ActivityLogCategory'
+ */
+export type EnumActivityLogCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ActivityLogCategory'>;
+/**
+ * Reference to a field of type 'ActivityLogCategory[]'
+ */
+export type ListEnumActivityLogCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ActivityLogCategory[]'>;
+/**
+ * Reference to a field of type 'ActivityLogStatus'
+ */
+export type EnumActivityLogStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ActivityLogStatus'>;
+/**
+ * Reference to a field of type 'ActivityLogStatus[]'
+ */
+export type ListEnumActivityLogStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ActivityLogStatus[]'>;
+/**
+ * Reference to a field of type 'KnowledgeBaseStatus'
+ */
+export type EnumKnowledgeBaseStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'KnowledgeBaseStatus'>;
+/**
+ * Reference to a field of type 'KnowledgeBaseStatus[]'
+ */
+export type ListEnumKnowledgeBaseStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'KnowledgeBaseStatus[]'>;
+/**
+ * Reference to a field of type 'KnowledgeBaseDocumentStatus'
+ */
+export type EnumKnowledgeBaseDocumentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'KnowledgeBaseDocumentStatus'>;
+/**
+ * Reference to a field of type 'KnowledgeBaseDocumentStatus[]'
+ */
+export type ListEnumKnowledgeBaseDocumentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'KnowledgeBaseDocumentStatus[]'>;
+/**
+ * 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;
+    passwordResetToken?: Prisma.PasswordResetTokenOmit;
+    role?: Prisma.RoleOmit;
+    notification?: Prisma.NotificationOmit;
+    session?: Prisma.SessionOmit;
+    verificationToken?: Prisma.VerificationTokenOmit;
+    folder?: Prisma.FolderOmit;
+    workspace?: Prisma.WorkspaceOmit;
+    channel?: Prisma.ChannelOmit;
+    chat?: Prisma.ChatOmit;
+    copilotConversation?: Prisma.CopilotConversationOmit;
+    copilotMessage?: Prisma.CopilotMessageOmit;
+    fileAsset?: Prisma.FileAssetOmit;
+    artifact?: Prisma.ArtifactOmit;
+    artifactVersion?: Prisma.ArtifactVersionOmit;
+    studyGuideHighlight?: Prisma.StudyGuideHighlightOmit;
+    studyGuideComment?: Prisma.StudyGuideCommentOmit;
+    flashcard?: Prisma.FlashcardOmit;
+    flashcardProgress?: Prisma.FlashcardProgressOmit;
+    worksheetQuestion?: Prisma.WorksheetQuestionOmit;
+    worksheetQuestionProgress?: Prisma.WorksheetQuestionProgressOmit;
+    worksheetPreset?: Prisma.WorksheetPresetOmit;
+    workspaceMember?: Prisma.WorkspaceMemberOmit;
+    workspaceInvitation?: Prisma.WorkspaceInvitationOmit;
+    podcastSegment?: Prisma.PodcastSegmentOmit;
+    invoice?: Prisma.InvoiceOmit;
+    plan?: Prisma.PlanOmit;
+    planLimit?: Prisma.PlanLimitOmit;
+    subscription?: Prisma.SubscriptionOmit;
+    resourcePrice?: Prisma.ResourcePriceOmit;
+    userCredit?: Prisma.UserCreditOmit;
+    idempotencyRecord?: Prisma.IdempotencyRecordOmit;
+    stripeEvent?: Prisma.StripeEventOmit;
+    activityLog?: Prisma.ActivityLogOmit;
+    knowledgeBase?: Prisma.KnowledgeBaseOmit;
+    workspaceKnowledgeBase?: Prisma.WorkspaceKnowledgeBaseOmit;
+    knowledgeBaseDocument?: Prisma.KnowledgeBaseDocumentOmit;
+    knowledgeBaseChunk?: Prisma.KnowledgeBaseChunkOmit;
+};
+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>;