@librechat/data-schemas 0.0.40 → 0.0.42

package/dist/types/methods/index.d.ts

@@ -26,7 +26,7 @@
 /// <reference types="mongoose/types/inferrawdoctype" />
 import { DEFAULT_REFRESH_TOKEN_EXPIRY, type SessionMethods } from './session';
 import { type TokenMethods } from './token';
-import { type RoleMethods } from './role';
+import { type RoleMethods, type RoleDeps } from './role';
 import { DEFAULT_SESSION_EXPIRY, type UserMethods } from './user';
 export { DEFAULT_REFRESH_TOKEN_EXPIRY, DEFAULT_SESSION_EXPIRY };
 import { type KeyMethods } from './key';
@@ -39,12 +39,43 @@ import { type PluginAuthMethods } from './pluginAuth';
 import { type AccessRoleMethods } from './accessRole';
 import { type UserGroupMethods } from './userGroup';
 import { type AclEntryMethods } from './aclEntry';
+import { type SystemGrantMethods } from './systemGrant';
 import { type ShareMethods } from './share';
+import { type ActionMethods } from './action';
+import { type AssistantMethods } from './assistant';
+import { type BannerMethods } from './banner';
+import { type ToolCallMethods } from './toolCall';
+import { type CategoriesMethods } from './categories';
+import { type PresetMethods } from './preset';
+import { type ConversationTagMethods } from './conversationTag';
+import { type MessageMethods } from './message';
+import { type ConversationMethods } from './conversation';
+import { type TxMethods, tokenValues, cacheTokenValues, premiumTokenValues, defaultRate } from './tx';
 import { type TransactionMethods } from './transaction';
-export type AllMethods = UserMethods & SessionMethods & TokenMethods & RoleMethods & KeyMethods & FileMethods & MemoryMethods & AgentCategoryMethods & AgentApiKeyMethods & MCPServerMethods & UserGroupMethods & AclEntryMethods & ShareMethods & AccessRoleMethods & PluginAuthMethods & TransactionMethods;
+import { type SpendTokensMethods } from './spendTokens';
+import { type PromptMethods } from './prompt';
+import { type AgentMethods } from './agent';
+import { type ConfigMethods } from './config';
+export { tokenValues, cacheTokenValues, premiumTokenValues, defaultRate };
+export type AllMethods = UserMethods & SessionMethods & TokenMethods & RoleMethods & KeyMethods & FileMethods & MemoryMethods & AgentCategoryMethods & AgentApiKeyMethods & MCPServerMethods & UserGroupMethods & AclEntryMethods & SystemGrantMethods & ShareMethods & AccessRoleMethods & PluginAuthMethods & ActionMethods & AssistantMethods & BannerMethods & ToolCallMethods & CategoriesMethods & PresetMethods & ConversationTagMethods & MessageMethods & ConversationMethods & TxMethods & TransactionMethods & SpendTokensMethods & PromptMethods & AgentMethods & ConfigMethods;
+/** Dependencies injected from the api layer into createMethods */
+export interface CreateMethodsDeps {
+    /** Matches a model name to a canonical key. From @librechat/api. */
+    matchModelName?: (model: string, endpoint?: string) => string | undefined;
+    /** Finds the first key in values whose key is a substring of model. From @librechat/api. */
+    findMatchingPattern?: (model: string, values: Record<string, number | Record<string, number>>) => string | undefined;
+    /** Removes all ACL permissions for a resource. From PermissionService. */
+    removeAllPermissions?: (params: {
+        resourceType: string;
+        resourceId: unknown;
+    }) => Promise<void>;
+    /** Returns a cache store for the given key. From getLogStores. */
+    getCache?: RoleDeps['getCache'];
+}
 /**
  * Creates all database methods for all collections
  * @param mongoose - Mongoose instance
+ * @param deps - Optional dependencies injected from the api layer
  */
-export declare function createMethods(mongoose: typeof import('mongoose')): AllMethods;
-export type { UserMethods, SessionMethods, TokenMethods, RoleMethods, KeyMethods, FileMethods, MemoryMethods, AgentCategoryMethods, AgentApiKeyMethods, MCPServerMethods, UserGroupMethods, AclEntryMethods, ShareMethods, AccessRoleMethods, PluginAuthMethods, TransactionMethods, };
+export declare function createMethods(mongoose: typeof import('mongoose'), deps?: CreateMethodsDeps): AllMethods;
+export type { UserMethods, SessionMethods, TokenMethods, RoleMethods, KeyMethods, FileMethods, MemoryMethods, AgentCategoryMethods, AgentApiKeyMethods, MCPServerMethods, UserGroupMethods, AclEntryMethods, SystemGrantMethods, ShareMethods, AccessRoleMethods, PluginAuthMethods, ActionMethods, AssistantMethods, BannerMethods, ToolCallMethods, CategoriesMethods, PresetMethods, ConversationTagMethods, MessageMethods, ConversationMethods, TxMethods, TransactionMethods, SpendTokensMethods, PromptMethods, AgentMethods, ConfigMethods, };

package/dist/types/methods/memory.d.ts

@@ -31,5 +31,6 @@ export declare function createMemoryMethods(mongoose: typeof import('mongoose'))
     deleteMemory: ({ userId, key }: t.DeleteMemoryParams) => Promise<t.MemoryResult>;
     getAllUserMemories: (userId: string | Types.ObjectId) => Promise<t.IMemoryEntryLean[]>;
     getFormattedMemories: ({ userId, }: t.GetFormattedMemoriesParams) => Promise<t.FormattedMemoriesResult>;
+    deleteAllUserMemories: (userId: string | Types.ObjectId) => Promise<number>;
 };
 export type MemoryMethods = ReturnType<typeof createMemoryMethods>;

package/dist/types/methods/message.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import type { DeleteResult, FilterQuery } from 'mongoose';
+import type { AppConfig, IMessage } from '~/types';
+export interface MessageMethods {
+    saveMessage(ctx: {
+        userId: string;
+        isTemporary?: boolean;
+        interfaceConfig?: AppConfig['interfaceConfig'];
+    }, params: Partial<IMessage> & {
+        newMessageId?: string;
+    }, metadata?: {
+        context?: string;
+    }): Promise<IMessage | null | undefined>;
+    bulkSaveMessages(messages: Array<Partial<IMessage>>, overrideTimestamp?: boolean): Promise<unknown>;
+    recordMessage(params: {
+        user: string;
+        endpoint?: string;
+        messageId: string;
+        conversationId?: string;
+        parentMessageId?: string;
+        [key: string]: unknown;
+    }): Promise<IMessage | null>;
+    updateMessageText(userId: string, params: {
+        messageId: string;
+        text: string;
+    }): Promise<void>;
+    updateMessage(userId: string, message: Partial<IMessage> & {
+        newMessageId?: string;
+    }, metadata?: {
+        context?: string;
+    }): Promise<Partial<IMessage>>;
+    deleteMessagesSince(userId: string, params: {
+        messageId: string;
+        conversationId: string;
+    }): Promise<DeleteResult>;
+    getMessages(filter: FilterQuery<IMessage>, select?: string): Promise<IMessage[]>;
+    getMessage(params: {
+        user: string;
+        messageId: string;
+    }): Promise<IMessage | null>;
+    getMessagesByCursor(filter: FilterQuery<IMessage>, options?: {
+        sortField?: string;
+        sortOrder?: 1 | -1;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<{
+        messages: IMessage[];
+        nextCursor: string | null;
+    }>;
+    searchMessages(query: string, searchOptions: Partial<IMessage>, hydrate?: boolean): Promise<unknown>;
+    deleteMessages(filter: FilterQuery<IMessage>): Promise<DeleteResult>;
+}
+export declare function createMessageMethods(mongoose: typeof import('mongoose')): MessageMethods;

package/dist/types/methods/preset.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+interface IPreset {
+    user?: string;
+    presetId?: string;
+    order?: number;
+    defaultPreset?: boolean;
+    tools?: (string | {
+        pluginKey?: string;
+    })[];
+    updatedAt?: Date;
+    [key: string]: unknown;
+}
+export declare function createPresetMethods(mongoose: typeof import('mongoose')): {
+    getPreset: (user: string, presetId: string) => Promise<(import("mongoose").FlattenMaps<{
+        [x: string]: unknown;
+        user?: string | undefined;
+        presetId?: string | undefined;
+        order?: number | undefined;
+        defaultPreset?: boolean | undefined;
+        tools?: (string | {
+            pluginKey?: string | undefined;
+        })[] | undefined;
+        updatedAt?: Date | undefined;
+    }> & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | {
+        message: string;
+    } | null>;
+    getPresets: (user: string, filter?: Record<string, unknown>) => Promise<(import("mongoose").FlattenMaps<{
+        [x: string]: unknown;
+        user?: string | undefined;
+        presetId?: string | undefined;
+        order?: number | undefined;
+        defaultPreset?: boolean | undefined;
+        tools?: (string | {
+            pluginKey?: string | undefined;
+        })[] | undefined;
+        updatedAt?: Date | undefined;
+    }> & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    })[] | {
+        message: string;
+    }>;
+    savePreset: (user: string, { presetId, newPresetId, defaultPreset, ...preset }: {
+        [key: string]: unknown;
+        presetId?: string | undefined;
+        newPresetId?: string | undefined;
+        defaultPreset?: boolean | undefined;
+    }) => Promise<(import("mongoose").Document<unknown, {}, IPreset> & IPreset & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | {
+        message: string;
+    }>;
+    deletePresets: (user: string, filter?: Record<string, unknown>) => Promise<import("mongodb").DeleteResult>;
+};
+export type PresetMethods = ReturnType<typeof createPresetMethods>;
+export {};

package/dist/types/methods/prompt.d.ts

@@ -0,0 +1,410 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import type { Model, Types } from 'mongoose';
+import type { IPrompt, IPromptGroupDocument } from '~/types';
+export interface PromptDeps {
+    /** Removes all ACL permissions for a resource. Injected from PermissionService. */
+    removeAllPermissions: (params: {
+        resourceType: string;
+        resourceId: unknown;
+    }) => Promise<void>;
+    /** Returns resource IDs solely owned by the given user. From createAclEntryMethods. */
+    getSoleOwnedResourceIds: (userObjectId: Types.ObjectId, resourceTypes: string | string[]) => Promise<Types.ObjectId[]>;
+}
+export declare function createPromptMethods(mongoose: typeof import('mongoose'), deps: PromptDeps): {
+    getPromptGroups: (filter: Record<string, unknown>) => Promise<{
+        promptGroups: Record<string, unknown>[];
+        pageNumber: string;
+        pageSize: string;
+        pages: string;
+        message?: undefined;
+    } | {
+        message: string;
+        promptGroups?: undefined;
+        pageNumber?: undefined;
+        pageSize?: undefined;
+        pages?: undefined;
+    }>;
+    deletePromptGroup: ({ _id }: {
+        _id: string;
+    }) => Promise<{
+        message: string;
+    }>;
+    getAllPromptGroups: (filter: Record<string, unknown>) => Promise<Record<string, unknown>[] | {
+        message: string;
+    }>;
+    getListPromptGroupsByAccess: ({ accessibleIds, otherParams, limit, after, }: {
+        accessibleIds?: Types.ObjectId[] | undefined;
+        otherParams?: Record<string, unknown> | undefined;
+        limit?: number | null | undefined;
+        after?: string | null | undefined;
+    }) => Promise<{
+        object: "list";
+        data: Record<string, unknown>[];
+        first_id: string | null;
+        last_id: string | null;
+        has_more: boolean;
+        after: string | null;
+    }>;
+    createPromptGroup: (saveData: {
+        prompt: Record<string, unknown>;
+        group: Record<string, unknown>;
+        author: string;
+        authorName: string;
+    }) => Promise<{
+        prompt: import("mongoose").FlattenMaps<IPrompt> & Required<{
+            _id: import("mongoose").FlattenMaps<unknown>;
+        }> & {
+            __v: number;
+        };
+        group: {
+            productionPrompt: {
+                prompt: string;
+            };
+            name: string;
+            numberOfGenerations: number;
+            oneliner: string;
+            category: string;
+            productionId: Types.ObjectId;
+            author: Types.ObjectId;
+            authorName: string;
+            command?: string | undefined;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+            isPublic?: boolean | undefined;
+            tenantId?: string | undefined;
+            _id: import("mongoose").FlattenMaps<unknown>;
+            $assertPopulated: <Paths = {}>(path: string | string[], values?: Partial<Paths> | undefined) => Omit<IPromptGroupDocument, keyof Paths> & Paths;
+            $clearModifiedPaths: () => IPromptGroupDocument;
+            $clone: () => IPromptGroupDocument;
+            $createModifiedPathsSnapshot: () => import("mongoose").ModifiedPathsSnapshot;
+            $getAllSubdocs: () => import("mongoose").Document<unknown, any, any>[];
+            $ignore: (path: string) => void;
+            $isDefault: (path: string) => boolean;
+            $isDeleted: (val?: boolean | undefined) => boolean;
+            $getPopulatedDocs: () => import("mongoose").Document<unknown, any, any>[];
+            $inc: (path: string | string[], val?: number | undefined) => IPromptGroupDocument;
+            $isEmpty: (path: string) => boolean;
+            $isValid: (path: string) => boolean;
+            $locals: import("mongoose").FlattenMaps<Record<string, unknown>>;
+            $markValid: (path: string) => void;
+            $model: {
+                <ModelType = Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }, any>>(name: string): ModelType;
+                <ModelType_1 = Model<any, {}, {}, {}, any, any>>(): ModelType_1;
+            };
+            $op: "save" | "validate" | "remove" | null;
+            $restoreModifiedPathsSnapshot: (snapshot: import("mongoose").ModifiedPathsSnapshot) => IPromptGroupDocument;
+            $session: (session?: import("mongodb").ClientSession | null | undefined) => import("mongodb").ClientSession | null;
+            $set: {
+                (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions | undefined): IPromptGroupDocument;
+                (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions | undefined): IPromptGroupDocument;
+                (value: string | Record<string, any>): IPromptGroupDocument;
+            };
+            $where: import("mongoose").FlattenMaps<Record<string, unknown>>;
+            baseModelName?: string | undefined;
+            collection: import("mongoose").Collection<import("bson").Document>;
+            db: import("mongoose").FlattenMaps<import("mongoose").Connection>;
+            deleteOne: (options?: import("mongoose").QueryOptions<unknown> | undefined) => any;
+            depopulate: <Paths_1 = {}>(path?: string | string[] | undefined) => import("mongoose").MergeType<IPromptGroupDocument, Paths_1>;
+            directModifiedPaths: () => string[];
+            equals: (doc: import("mongoose").Document<unknown, any, any>) => boolean;
+            errors?: import("mongoose").Error.ValidationError | undefined;
+            get: {
+                <T extends string | number | symbol>(path: T, type?: any, options?: any): any;
+                (path: string, type?: any, options?: any): any;
+            };
+            getChanges: () => import("mongoose").UpdateQuery<IPromptGroupDocument>;
+            id?: any;
+            increment: () => IPromptGroupDocument;
+            init: (obj: import("mongoose").AnyObject, opts?: import("mongoose").AnyObject | undefined) => IPromptGroupDocument;
+            invalidate: {
+                <T_1 extends string | number | symbol>(path: T_1, errorMsg: string | NativeError, value?: any, kind?: string | undefined): NativeError | null;
+                (path: string, errorMsg: string | NativeError, value?: any, kind?: string | undefined): NativeError | null;
+            };
+            isDirectModified: {
+                <T_2 extends string | number | symbol>(path: T_2 | T_2[]): boolean;
+                (path: string | string[]): boolean;
+            };
+            isDirectSelected: {
+                <T_3 extends string | number | symbol>(path: T_3): boolean;
+                (path: string): boolean;
+            };
+            isInit: {
+                <T_4 extends string | number | symbol>(path: T_4): boolean;
+                (path: string): boolean;
+            };
+            isModified: {
+                <T_5 extends string | number | symbol>(path?: T_5 | T_5[] | undefined, options?: {
+                    ignoreAtomics?: boolean | undefined;
+                } | null | undefined): boolean;
+                (path?: string | string[] | undefined, options?: {
+                    ignoreAtomics?: boolean | undefined;
+                } | null | undefined): boolean;
+            };
+            isNew: boolean;
+            isSelected: {
+                <T_6 extends string | number | symbol>(path: T_6): boolean;
+                (path: string): boolean;
+            };
+            markModified: {
+                <T_7 extends string | number | symbol>(path: T_7, scope?: any): void;
+                (path: string, scope?: any): void;
+            };
+            model: {
+                <ModelType_2 = Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }, any>>(name: string): ModelType_2;
+                <ModelType_3 = Model<any, {}, {}, {}, any, any>>(): ModelType_3;
+            };
+            modifiedPaths: (options?: {
+                includeChildren?: boolean | undefined;
+            } | undefined) => string[];
+            overwrite: (obj: import("mongoose").AnyObject) => IPromptGroupDocument;
+            $parent: () => import("mongoose").Document<unknown, any, any> | undefined;
+            populate: {
+                <Paths_2 = {}>(path: string | import("mongoose").PopulateOptions | (string | import("mongoose").PopulateOptions)[]): Promise<import("mongoose").MergeType<IPromptGroupDocument, Paths_2>>;
+                <Paths_3 = {}>(path: string, select?: string | import("mongoose").AnyObject | undefined, model?: Model<any, {}, {}, {}, any, any> | undefined, match?: import("mongoose").AnyObject | undefined, options?: import("mongoose").PopulateOptions | undefined): Promise<import("mongoose").MergeType<IPromptGroupDocument, Paths_3>>;
+            };
+            populated: (path: string) => any;
+            replaceOne: (replacement?: import("mongoose").AnyObject | undefined, options?: import("mongoose").QueryOptions<unknown> | null | undefined) => import("mongoose").Query<any, IPromptGroupDocument, {}, unknown, "find", Record<string, never>>;
+            save: (options?: import("mongoose").SaveOptions | undefined) => Promise<IPromptGroupDocument>;
+            schema: import("mongoose").FlattenMaps<import("mongoose").Schema<any, Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+                [x: string]: unknown;
+            }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+                [x: string]: unknown;
+            }>> & import("mongoose").FlatRecord<{
+                [x: string]: unknown;
+            }> & Required<{
+                _id: unknown;
+            }> & {
+                __v: number;
+            }>>;
+            set: {
+                <T_8 extends string | number | symbol>(path: T_8, val: any, type: any, options?: import("mongoose").DocumentSetOptions | undefined): IPromptGroupDocument;
+                (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions | undefined): IPromptGroupDocument;
+                (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions | undefined): IPromptGroupDocument;
+                (value: string | Record<string, any>): IPromptGroupDocument;
+            };
+            toJSON: {
+                (options?: (import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenMaps?: true | undefined;
+                    flattenObjectIds?: false | undefined;
+                }) | undefined): import("mongoose").FlattenMaps<any>;
+                (options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenObjectIds: false;
+                }): import("mongoose").FlattenMaps<any>;
+                (options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenObjectIds: true;
+                }): {
+                    [x: string]: any;
+                };
+                (options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenMaps: false;
+                }): any;
+                (options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenMaps: false;
+                    flattenObjectIds: true;
+                }): any;
+                <T_9 = any>(options?: (import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenMaps?: true | undefined;
+                    flattenObjectIds?: false | undefined;
+                }) | undefined): import("mongoose").FlattenMaps<T_9>;
+                <T_10 = any>(options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenObjectIds: false;
+                }): import("mongoose").FlattenMaps<T_10>;
+                <T_11 = any>(options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenObjectIds: true;
+                }): import("mongoose").ObjectIdToString<import("mongoose").FlattenMaps<T_11>>;
+                <T_12 = any>(options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenMaps: false;
+                }): T_12;
+                <T_13 = any>(options: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> & {
+                    flattenMaps: false;
+                    flattenObjectIds: true;
+                }): import("mongoose").ObjectIdToString<T_13>;
+            };
+            toObject: {
+                (options?: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> | undefined): any;
+                <T_14>(options?: import("mongoose").ToObjectOptions<import("mongoose").Document<unknown, {}, unknown> & {
+                    _id: Types.ObjectId;
+                } & {
+                    __v: number;
+                }> | undefined): import("mongoose").Default__v<import("mongoose").Require_id<T_14>>;
+            };
+            unmarkModified: {
+                <T_15 extends string | number | symbol>(path: T_15): void;
+                (path: string): void;
+            };
+            updateOne: (update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<IPromptGroupDocument> | undefined, options?: import("mongoose").QueryOptions<unknown> | null | undefined) => import("mongoose").Query<any, IPromptGroupDocument, {}, unknown, "find", Record<string, never>>;
+            validate: {
+                <T_16 extends string | number | symbol>(pathsToValidate?: T_16 | T_16[] | undefined, options?: import("mongoose").AnyObject | undefined): Promise<void>;
+                (pathsToValidate?: import("mongoose").PathsToValidate | undefined, options?: import("mongoose").AnyObject | undefined): Promise<void>;
+                (options: {
+                    pathsToSkip?: import("mongoose").pathsToSkip | undefined;
+                }): Promise<void>;
+            };
+            validateSync: {
+                (options: {
+                    [k: string]: any;
+                    pathsToSkip?: import("mongoose").pathsToSkip | undefined;
+                }): import("mongoose").Error.ValidationError | null;
+                <T_17 extends string | number | symbol>(pathsToValidate?: T_17 | T_17[] | undefined, options?: import("mongoose").AnyObject | undefined): import("mongoose").Error.ValidationError | null;
+                (pathsToValidate?: import("mongoose").PathsToValidate | undefined, options?: import("mongoose").AnyObject | undefined): import("mongoose").Error.ValidationError | null;
+            };
+            __v: number;
+        };
+    }>;
+    savePrompt: (saveData: {
+        prompt: Record<string, unknown>;
+        author: string | Types.ObjectId;
+    }) => Promise<{
+        prompt: import("mongoose").Document<unknown, {}, IPrompt> & IPrompt & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        };
+        message?: undefined;
+    } | {
+        message: string;
+        prompt?: undefined;
+    }>;
+    getPrompts: (filter: Record<string, unknown>) => Promise<(import("mongoose").FlattenMaps<IPrompt> & Required<{
+        _id: import("mongoose").FlattenMaps<unknown>;
+    }> & {
+        __v: number;
+    })[] | {
+        message: string;
+    }>;
+    getPrompt: (filter: Record<string, unknown>) => Promise<(import("mongoose").FlattenMaps<IPrompt> & Required<{
+        _id: import("mongoose").FlattenMaps<unknown>;
+    }> & {
+        __v: number;
+    }) | {
+        message: string;
+    } | null>;
+    getRandomPromptGroups: (filter: {
+        skip: number | string;
+        limit: number | string;
+    }) => Promise<{
+        prompts: unknown[];
+        message?: undefined;
+    } | {
+        message: string;
+        prompts?: undefined;
+    }>;
+    getPromptGroupsWithPrompts: (filter: Record<string, unknown>) => Promise<(import("mongoose").FlattenMaps<IPromptGroupDocument> & Required<{
+        _id: import("mongoose").FlattenMaps<unknown>;
+    }> & {
+        __v: number;
+    }) | {
+        message: string;
+    } | null>;
+    getPromptGroup: (filter: Record<string, unknown>) => Promise<(import("mongoose").FlattenMaps<IPromptGroupDocument> & Required<{
+        _id: import("mongoose").FlattenMaps<unknown>;
+    }> & {
+        __v: number;
+    }) | {
+        message: string;
+    } | null>;
+    deletePrompt: ({ promptId, groupId, }: {
+        promptId: string | Types.ObjectId;
+        groupId: string | Types.ObjectId;
+    }) => Promise<{
+        prompt: string;
+        promptGroup: {
+            message: string;
+            id: string | Types.ObjectId;
+        };
+    } | {
+        prompt: string;
+        promptGroup?: undefined;
+    }>;
+    deleteUserPrompts: (userId: string) => Promise<void>;
+    updatePromptGroup: (filter: Record<string, unknown>, data: Record<string, unknown>) => Promise<(import("mongoose").Document<unknown, {}, IPromptGroupDocument> & IPromptGroupDocument & Required<{
+        _id: unknown;
+    }> & {
+        __v: number;
+    }) | {
+        message: string;
+    }>;
+    makePromptProduction: (promptId: string) => Promise<{
+        message: string;
+    }>;
+    updatePromptLabels: (_id: string, labels: unknown) => Promise<{
+        message: string;
+    }>;
+};
+export type PromptMethods = ReturnType<typeof createPromptMethods>;