Remchanv2/dist/lib.d.ts

/// <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" />
export const Random: string;
import { GatewayIntentBits } from "discord-api-types/gateway/v10";
import { Partials } from "discord.js";
import { ActivityType } from "discord-api-types/payloads/v10/gateway";
import { Message } from "discord.js";
declare class command {
    /**
     * @param {_Client} client extends discord.js.Client
     * @param {CommandOptions} options extends Lib.Options
     */
    constructor(client: _Client, options: CommandOptions);
    name: string;
    aliases: string[];
    description: string;
    needsAdmin: boolean;
    hidden: boolean;
    client: _Client;
}
declare class _Client extends Client<boolean> {
    /**
     *
     * @param {ClientOptions} options
     */
    constructor(options: ClientOptions);
    commands: any[];
    rustCommits: rustCommits;
    freegames: FreeGames;
    /**
     * Register a group of commands under the folder commands
     * @param {String} name - Name of the group.
     * @param {String} folderName - Name of the folder.
     */
    enableCommands(): Promise<void>;
    /**
     *
     * @param {String} name - Command Name
     * @returns {command}
     */
    onList(name: string): command;
    RoleSetter(): Promise<void>;
}
export namespace ErrorType {
    const Permissions: string;
    const Arguments: string;
    const NoArguments: string;
    const NotOnTheList: string;
    const OldMessages: string;
}
export class Channel {
    /**
     *
     * @param {String} channelID
     */
    constructor(channelID: string);
    channel: string;
}
export class ErrorMessage {
    /**
     * @param {_Client} client
     */
    constructor(client: _Client);
    client: _Client;
    /**
     *
     * @param {ErrorType} errorType
     * @param {Message} message
     * @param {String[]} extraMessages
     */
    send(errorType: {
        Permissions: string;
        Arguments: string;
        NoArguments: string;
        NotOnTheList: string;
        OldMessages: string;
    }, message: Message, extraMessages: string[]): Promise<void>;
}
declare class AnilistCli {
    /**
     *
     * @param {String} ss - Search Query
     * @returns {AnimeInfo}
     */
    searchAnime(ss: string): AnimeInfo;
    /**
     *
     * @param {String} ss - Search Query
     * @returns {CharInfo}
     */
    searchChar(ss: string): CharInfo;
    /**
     *
     * @param {String} ss - Search Query
     * @returns {MangaInfo}
     */
    searchManga(ss: string): MangaInfo;
}
declare class CommandOptions {
    /**
     *
     * @param {String} name
     * @param {String[]} aliases
     * @param {String} description
     * @param {Boolean} needsAdmin
     * @param {Boolean} hidden
     */
    constructor(name: string, aliases: string[], description: string, needsAdmin: boolean, hidden: boolean);
    name: string;
    aliases: string[];
    description: string;
    needsAdmin: boolean;
    hidden: boolean;
}
import { Client } from "discord.js";
declare class rustCommits {
    /**
     *
     * @param {_Client} client
     */
    constructor(client: _Client);
    client: _Client;
    update(): Promise<void>;
    channels: {
        new <DocType = {
            cID: string;
            for: string;
            name?: string;
        }>(doc?: DocType, fields?: any, options?: boolean | import("mongoose").AnyObject): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        aggregate<R = any>(pipeline?: import("mongoose").PipelineStage[], options?: import("mongodb").AggregateOptions, callback?: import("mongoose").Callback<R[]>): import("mongoose").Aggregate<R[]>;
        aggregate<R_1 = any>(pipeline: import("mongoose").PipelineStage[], callback?: import("mongoose").Callback<R_1[]>): import("mongoose").Aggregate<R_1[]>;
        base: typeof import("mongoose");
        baseModelName: string;
        castObject(obj: import("mongoose").AnyObject, options?: {
            ignoreCastErrors?: boolean;
        }): {
            cID: string;
            for: string;
            name?: string;
        };
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions, callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options?: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions): Promise<import("mongodb").BulkWriteResult>;
        bulkSave(documents: import("mongoose").Document<any, any, any>[], options?: import("mongodb").BulkWriteOptions & {
            timestamps?: boolean;
        }): Promise<import("mongodb").BulkWriteResult>;
        collection: import("mongoose").Collection<import("bson").Document>;
        count(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        count(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        create<DocContents = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents)[], options?: import("mongoose").SaveOptions): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_1 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_1)[], options?: import("mongoose").SaveOptions, callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_2 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_2)[], callback: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): void;
        create<DocContents_3 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_3): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        create<DocContents_4 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(...docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_4)[]): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_5 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_5, callback: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): void;
        createCollection<T extends import("bson").Document>(options: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">, callback: import("mongoose").Callback<import("mongodb").Collection<T>>): void;
        createCollection<T_1 extends import("bson").Document>(callback: import("mongoose").Callback<import("mongodb").Collection<T_1>>): void;
        createCollection<T_2 extends import("bson").Document>(options?: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">): Promise<import("mongodb").Collection<T_2>>;
        db: import("mongoose").Connection;
        deleteMany(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        events: NodeJS.EventEmitter;
        findById<ResultDoc = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc>): import("mongoose").Query<ResultDoc, ResultDoc, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findById<ResultDoc_1 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_1>): import("mongoose").Query<ResultDoc_1, ResultDoc_1, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_2 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_2>): import("mongoose").Query<ResultDoc_2, ResultDoc_2, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_3 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_3>): import("mongoose").Query<ResultDoc_3, ResultDoc_3, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_4 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_4>): import("mongoose").Query<ResultDoc_4, ResultDoc_4, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        hydrate(obj: any, projection?: import("mongoose").AnyObject, options?: {
            setters?: boolean;
        }): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        init(callback?: import("mongoose").CallbackWithoutResult): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        insertMany<DocContents_6 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_6)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_6>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_7 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_7)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_8 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_8)[], callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_8>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_9 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_9, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_9>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_10 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_10, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_11 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_11, options: import("mongoose").InsertManyOptions & {
            lean?: false;
        }, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_11>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_12 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_12, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_12>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_13 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_13)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_13>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_14 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_14)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_15 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_15)[]): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_15>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_16 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_16, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_16>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_17 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_17, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_18 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_18, options: import("mongoose").InsertManyOptions): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_18>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_19 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_19): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_19>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        modelName: string;
        populate(docs: any[], options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        populate(doc: any, options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        validate(callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, pathsToValidate: import("mongoose").PathsToValidate, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        watch<ResultType extends import("bson").Document = any>(pipeline?: Record<string, unknown>[], options?: import("mongodb").ChangeStreamOptions & {
            hydrate?: boolean;
        }): import("mongodb").ChangeStream<ResultType, import("mongodb").ChangeStreamDocument<ResultType>>;
        $where(argument: string | Function): import("mongoose").Query<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        discriminators: {
            [name: string]: import("mongoose").Model<any, {}, {}, {}, any>;
        };
        translateAliases(raw: any): any;
        distinct<ReturnType_1 = any>(field: string, filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<ReturnType_1[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        estimatedDocumentCount(options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").Callback<{
            _id: import("mongoose").Types.ObjectId;
        }>): import("mongoose").Query<Pick<import("mongoose").Document<{
            cID: string;
            for: string;
            name?: string;
        }, any, any>, "_id">, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>): import("mongoose").Query<{
            _id: import("mongoose").Types.ObjectId;
        }, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_5 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_5[]>): import("mongoose").Query<ResultDoc_5[], ResultDoc_5, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_6 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_6[]>): import("mongoose").Query<ResultDoc_6[], ResultDoc_6, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_7 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_7[]>): import("mongoose").Query<ResultDoc_7[], ResultDoc_7, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_8 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(callback?: import("mongoose").Callback<ResultDoc_8[]>): import("mongoose").Query<ResultDoc_8[], ResultDoc_8, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndDelete<ResultDoc_9 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_9, res: any) => void): import("mongoose").Query<ResultDoc_9, ResultDoc_9, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndRemove<ResultDoc_10 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_10, res: any) => void): import("mongoose").Query<ResultDoc_10, ResultDoc_10, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_11 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_11>, ResultDoc_11, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_12 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_12, res: any) => void): import("mongoose").Query<ResultDoc_12, ResultDoc_12, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_13 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_13, res: any) => void): import("mongoose").Query<ResultDoc_13, ResultDoc_13, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_14 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: (err: NativeError, doc: ResultDoc_14, res: any) => void): import("mongoose").Query<ResultDoc_14, ResultDoc_14, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndDelete<ResultDoc_15 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_15, res: any) => void): import("mongoose").Query<ResultDoc_15, ResultDoc_15, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndRemove<ResultDoc_16 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_16, res: any) => void): import("mongoose").Query<ResultDoc_16, ResultDoc_16, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_17 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_17>, ResultDoc_17, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_18 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_18, res: any) => void): import("mongoose").Query<ResultDoc_18, ResultDoc_18, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_19 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_19, res: any) => void): import("mongoose").Query<ResultDoc_19, ResultDoc_19, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_20 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_20>, ResultDoc_20, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_21 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_21, res: any) => void): import("mongoose").Query<ResultDoc_21, ResultDoc_21, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_22 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: {
            cID: string;
            for: string;
            name?: string;
        }, res: any) => void): import("mongoose").Query<ResultDoc_22, ResultDoc_22, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        geoSearch<ResultDoc_23 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").GeoSearchOptions, callback?: import("mongoose").Callback<ResultDoc_23[]>): import("mongoose").Query<ResultDoc_23[], ResultDoc_23, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        mapReduce<Key, Value>(o: import("mongoose").MapReduceOptions<{
            cID: string;
            for: string;
            name?: string;
        }, Key, Value>, callback?: import("mongoose").Callback<any>): Promise<any>;
        remove<ResultDoc_24 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_24, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        remove<ResultDoc_25 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, options?: import("mongoose").RemoveOptions, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_25, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        replaceOne<ResultDoc_26 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_26, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        schema: import("mongoose").Schema<{
            cID: string;
            for: string;
            name?: string;
        }, import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>;
        update<ResultDoc_27 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_27, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateMany<ResultDoc_28 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_28, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateOne<ResultDoc_29 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_29, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_30 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(path: string, val?: any): import("mongoose").Query<ResultDoc_30[], ResultDoc_30, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_31 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(obj: object): import("mongoose").Query<ResultDoc_31[], ResultDoc_31, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_32 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(): import("mongoose").Query<ResultDoc_32[], ResultDoc_32, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        on(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        once(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        off(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeAllListeners(event?: string | symbol): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        setMaxListeners(n: number): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        eventNames(): (string | symbol)[];
        discriminator<D>(name: string | number, schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            [x: string]: any;
        }>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): import("mongoose").Model<D, {}, {}, {}, any>;
        discriminator<T_3, U>(name: string | number, schema: import("mongoose").Schema<T_3, U, {}, {}, {}, {}, "type", import("mongoose").ObtainDocumentType<any, T_3, "type">>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): U;
        createIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        diffIndexes(options: Record<string, unknown>, callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(options?: Record<string, unknown>): Promise<import("mongoose").IndexesDiff>;
        ensureIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        listIndexes(callback: import("mongoose").Callback<any[]>): void;
        listIndexes(): Promise<any[]>;
        syncIndexes(options: import("mongoose").SyncIndexesOptions, callback: import("mongoose").Callback<string[]>): void;
        syncIndexes(options?: import("mongoose").SyncIndexesOptions): Promise<string[]>;
        startSession(options: import("mongodb").ClientSessionOptions, callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(options?: import("mongodb").ClientSessionOptions): Promise<import("mongodb").ClientSession>;
        get: (callback: any, limit: any) => void;
    };
    /**
    *
    * @param {channelM} channels
    */
    resolveChannels(channels: {
        new <DocType = {
            cID: string;
            for: string;
            name?: string;
        }>(doc?: DocType, fields?: any, options?: boolean | import("mongoose").AnyObject): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        aggregate<R = any>(pipeline?: import("mongoose").PipelineStage[], options?: import("mongodb").AggregateOptions, callback?: import("mongoose").Callback<R[]>): import("mongoose").Aggregate<R[]>;
        aggregate<R_1 = any>(pipeline: import("mongoose").PipelineStage[], callback?: import("mongoose").Callback<R_1[]>): import("mongoose").Aggregate<R_1[]>;
        base: typeof import("mongoose");
        baseModelName: string;
        castObject(obj: import("mongoose").AnyObject, options?: {
            ignoreCastErrors?: boolean;
        }): {
            cID: string;
            for: string;
            name?: string;
        };
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions, callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options?: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions): Promise<import("mongodb").BulkWriteResult>;
        bulkSave(documents: import("mongoose").Document<any, any, any>[], options?: import("mongodb").BulkWriteOptions & {
            timestamps?: boolean;
        }): Promise<import("mongodb").BulkWriteResult>;
        collection: import("mongoose").Collection<import("bson").Document>;
        count(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        count(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        create<DocContents = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents)[], options?: import("mongoose").SaveOptions): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_1 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_1)[], options?: import("mongoose").SaveOptions, callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_2 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_2)[], callback: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): void;
        create<DocContents_3 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_3): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        create<DocContents_4 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(...docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_4)[]): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_5 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_5, callback: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): void;
        createCollection<T extends import("bson").Document>(options: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">, callback: import("mongoose").Callback<import("mongodb").Collection<T>>): void;
        createCollection<T_1 extends import("bson").Document>(callback: import("mongoose").Callback<import("mongodb").Collection<T_1>>): void;
        createCollection<T_2 extends import("bson").Document>(options?: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">): Promise<import("mongodb").Collection<T_2>>;
        db: import("mongoose").Connection;
        deleteMany(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        events: NodeJS.EventEmitter;
        findById<ResultDoc = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc>): import("mongoose").Query<ResultDoc, ResultDoc, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findById<ResultDoc_1 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_1>): import("mongoose").Query<ResultDoc_1, ResultDoc_1, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_2 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_2>): import("mongoose").Query<ResultDoc_2, ResultDoc_2, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_3 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_3>): import("mongoose").Query<ResultDoc_3, ResultDoc_3, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_4 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_4>): import("mongoose").Query<ResultDoc_4, ResultDoc_4, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        hydrate(obj: any, projection?: import("mongoose").AnyObject, options?: {
            setters?: boolean;
        }): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        init(callback?: import("mongoose").CallbackWithoutResult): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        insertMany<DocContents_6 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_6)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_6>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_7 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_7)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_8 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_8)[], callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_8>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_9 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_9, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_9>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_10 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_10, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_11 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_11, options: import("mongoose").InsertManyOptions & {
            lean?: false;
        }, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_11>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_12 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_12, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_12>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_13 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_13)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_13>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_14 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_14)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_15 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_15)[]): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_15>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_16 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_16, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_16>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_17 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_17, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_18 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_18, options: import("mongoose").InsertManyOptions): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_18>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_19 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_19): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_19>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        modelName: string;
        populate(docs: any[], options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        populate(doc: any, options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        validate(callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, pathsToValidate: import("mongoose").PathsToValidate, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        watch<ResultType extends import("bson").Document = any>(pipeline?: Record<string, unknown>[], options?: import("mongodb").ChangeStreamOptions & {
            hydrate?: boolean;
        }): import("mongodb").ChangeStream<ResultType, import("mongodb").ChangeStreamDocument<ResultType>>;
        $where(argument: string | Function): import("mongoose").Query<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        discriminators: {
            [name: string]: import("mongoose").Model<any, {}, {}, {}, any>;
        };
        translateAliases(raw: any): any;
        distinct<ReturnType_1 = any>(field: string, filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<ReturnType_1[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        estimatedDocumentCount(options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").Callback<{
            _id: import("mongoose").Types.ObjectId;
        }>): import("mongoose").Query<Pick<import("mongoose").Document<{
            cID: string;
            for: string;
            name?: string;
        }, any, any>, "_id">, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>): import("mongoose").Query<{
            _id: import("mongoose").Types.ObjectId;
        }, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_5 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_5[]>): import("mongoose").Query<ResultDoc_5[], ResultDoc_5, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_6 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_6[]>): import("mongoose").Query<ResultDoc_6[], ResultDoc_6, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_7 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_7[]>): import("mongoose").Query<ResultDoc_7[], ResultDoc_7, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_8 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(callback?: import("mongoose").Callback<ResultDoc_8[]>): import("mongoose").Query<ResultDoc_8[], ResultDoc_8, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndDelete<ResultDoc_9 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_9, res: any) => void): import("mongoose").Query<ResultDoc_9, ResultDoc_9, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndRemove<ResultDoc_10 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_10, res: any) => void): import("mongoose").Query<ResultDoc_10, ResultDoc_10, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_11 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_11>, ResultDoc_11, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_12 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_12, res: any) => void): import("mongoose").Query<ResultDoc_12, ResultDoc_12, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_13 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_13, res: any) => void): import("mongoose").Query<ResultDoc_13, ResultDoc_13, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_14 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: (err: NativeError, doc: ResultDoc_14, res: any) => void): import("mongoose").Query<ResultDoc_14, ResultDoc_14, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndDelete<ResultDoc_15 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_15, res: any) => void): import("mongoose").Query<ResultDoc_15, ResultDoc_15, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndRemove<ResultDoc_16 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_16, res: any) => void): import("mongoose").Query<ResultDoc_16, ResultDoc_16, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_17 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_17>, ResultDoc_17, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_18 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_18, res: any) => void): import("mongoose").Query<ResultDoc_18, ResultDoc_18, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_19 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_19, res: any) => void): import("mongoose").Query<ResultDoc_19, ResultDoc_19, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_20 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_20>, ResultDoc_20, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_21 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_21, res: any) => void): import("mongoose").Query<ResultDoc_21, ResultDoc_21, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_22 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: {
            cID: string;
            for: string;
            name?: string;
        }, res: any) => void): import("mongoose").Query<ResultDoc_22, ResultDoc_22, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        geoSearch<ResultDoc_23 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").GeoSearchOptions, callback?: import("mongoose").Callback<ResultDoc_23[]>): import("mongoose").Query<ResultDoc_23[], ResultDoc_23, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        mapReduce<Key, Value>(o: import("mongoose").MapReduceOptions<{
            cID: string;
            for: string;
            name?: string;
        }, Key, Value>, callback?: import("mongoose").Callback<any>): Promise<any>;
        remove<ResultDoc_24 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_24, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        remove<ResultDoc_25 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, options?: import("mongoose").RemoveOptions, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_25, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        replaceOne<ResultDoc_26 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_26, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        schema: import("mongoose").Schema<{
            cID: string;
            for: string;
            name?: string;
        }, import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>;
        update<ResultDoc_27 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_27, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateMany<ResultDoc_28 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_28, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateOne<ResultDoc_29 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_29, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_30 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(path: string, val?: any): import("mongoose").Query<ResultDoc_30[], ResultDoc_30, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_31 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(obj: object): import("mongoose").Query<ResultDoc_31[], ResultDoc_31, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_32 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(): import("mongoose").Query<ResultDoc_32[], ResultDoc_32, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        on(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        once(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        off(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeAllListeners(event?: string | symbol): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        setMaxListeners(n: number): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        eventNames(): (string | symbol)[];
        discriminator<D>(name: string | number, schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            [x: string]: any;
        }>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): import("mongoose").Model<D, {}, {}, {}, any>;
        discriminator<T_3, U>(name: string | number, schema: import("mongoose").Schema<T_3, U, {}, {}, {}, {}, "type", import("mongoose").ObtainDocumentType<any, T_3, "type">>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): U;
        createIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        diffIndexes(options: Record<string, unknown>, callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(options?: Record<string, unknown>): Promise<import("mongoose").IndexesDiff>;
        ensureIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        listIndexes(callback: import("mongoose").Callback<any[]>): void;
        listIndexes(): Promise<any[]>;
        syncIndexes(options: import("mongoose").SyncIndexesOptions, callback: import("mongoose").Callback<string[]>): void;
        syncIndexes(options?: import("mongoose").SyncIndexesOptions): Promise<string[]>;
        startSession(options: import("mongodb").ClientSessionOptions, callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(options?: import("mongodb").ClientSessionOptions): Promise<import("mongodb").ClientSession>;
        get: (callback: any, limit: any) => void;
    }): Promise<{
        new <DocType = {
            cID: string;
            for: string;
            name?: string;
        }>(doc?: DocType, fields?: any, options?: boolean | import("mongoose").AnyObject): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        aggregate<R = any>(pipeline?: import("mongoose").PipelineStage[], options?: import("mongodb").AggregateOptions, callback?: import("mongoose").Callback<R[]>): import("mongoose").Aggregate<R[]>;
        aggregate<R_1 = any>(pipeline: import("mongoose").PipelineStage[], callback?: import("mongoose").Callback<R_1[]>): import("mongoose").Aggregate<R_1[]>;
        base: typeof import("mongoose");
        baseModelName: string;
        castObject(obj: import("mongoose").AnyObject, options?: {
            ignoreCastErrors?: boolean;
        }): {
            cID: string;
            for: string;
            name?: string;
        };
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions, callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options?: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions): Promise<import("mongodb").BulkWriteResult>;
        bulkSave(documents: import("mongoose").Document<any, any, any>[], options?: import("mongodb").BulkWriteOptions & {
            timestamps?: boolean;
        }): Promise<import("mongodb").BulkWriteResult>;
        collection: import("mongoose").Collection<import("bson").Document>;
        count(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        count(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        create<DocContents = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents)[], options?: import("mongoose").SaveOptions): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_1 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_1)[], options?: import("mongoose").SaveOptions, callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_2 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_2)[], callback: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): void;
        create<DocContents_3 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_3): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        create<DocContents_4 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(...docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_4)[]): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_5 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_5, callback: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): void;
        createCollection<T extends import("bson").Document>(options: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">, callback: import("mongoose").Callback<import("mongodb").Collection<T>>): void;
        createCollection<T_1 extends import("bson").Document>(callback: import("mongoose").Callback<import("mongodb").Collection<T_1>>): void;
        createCollection<T_2 extends import("bson").Document>(options?: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">): Promise<import("mongodb").Collection<T_2>>;
        db: import("mongoose").Connection;
        deleteMany(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        events: NodeJS.EventEmitter;
        findById<ResultDoc = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc>): import("mongoose").Query<ResultDoc, ResultDoc, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findById<ResultDoc_1 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_1>): import("mongoose").Query<ResultDoc_1, ResultDoc_1, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_2 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_2>): import("mongoose").Query<ResultDoc_2, ResultDoc_2, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_3 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_3>): import("mongoose").Query<ResultDoc_3, ResultDoc_3, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_4 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_4>): import("mongoose").Query<ResultDoc_4, ResultDoc_4, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        hydrate(obj: any, projection?: import("mongoose").AnyObject, options?: {
            setters?: boolean;
        }): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        init(callback?: import("mongoose").CallbackWithoutResult): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        insertMany<DocContents_6 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_6)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_6>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_7 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_7)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_8 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_8)[], callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_8>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_9 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_9, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_9>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_10 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_10, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_11 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_11, options: import("mongoose").InsertManyOptions & {
            lean?: false;
        }, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_11>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_12 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_12, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_12>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_13 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_13)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_13>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_14 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_14)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_15 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_15)[]): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_15>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_16 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_16, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_16>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_17 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_17, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_18 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_18, options: import("mongoose").InsertManyOptions): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_18>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_19 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_19): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_19>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        modelName: string;
        populate(docs: any[], options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        populate(doc: any, options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        validate(callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, pathsToValidate: import("mongoose").PathsToValidate, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        watch<ResultType extends import("bson").Document = any>(pipeline?: Record<string, unknown>[], options?: import("mongodb").ChangeStreamOptions & {
            hydrate?: boolean;
        }): import("mongodb").ChangeStream<ResultType, import("mongodb").ChangeStreamDocument<ResultType>>;
        $where(argument: string | Function): import("mongoose").Query<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        discriminators: {
            [name: string]: import("mongoose").Model<any, {}, {}, {}, any>;
        };
        translateAliases(raw: any): any;
        distinct<ReturnType_1 = any>(field: string, filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<ReturnType_1[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        estimatedDocumentCount(options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").Callback<{
            _id: import("mongoose").Types.ObjectId;
        }>): import("mongoose").Query<Pick<import("mongoose").Document<{
            cID: string;
            for: string;
            name?: string;
        }, any, any>, "_id">, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>): import("mongoose").Query<{
            _id: import("mongoose").Types.ObjectId;
        }, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_5 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_5[]>): import("mongoose").Query<ResultDoc_5[], ResultDoc_5, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_6 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_6[]>): import("mongoose").Query<ResultDoc_6[], ResultDoc_6, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_7 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_7[]>): import("mongoose").Query<ResultDoc_7[], ResultDoc_7, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_8 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(callback?: import("mongoose").Callback<ResultDoc_8[]>): import("mongoose").Query<ResultDoc_8[], ResultDoc_8, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndDelete<ResultDoc_9 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_9, res: any) => void): import("mongoose").Query<ResultDoc_9, ResultDoc_9, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndRemove<ResultDoc_10 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_10, res: any) => void): import("mongoose").Query<ResultDoc_10, ResultDoc_10, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_11 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_11>, ResultDoc_11, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_12 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_12, res: any) => void): import("mongoose").Query<ResultDoc_12, ResultDoc_12, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_13 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_13, res: any) => void): import("mongoose").Query<ResultDoc_13, ResultDoc_13, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_14 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: (err: NativeError, doc: ResultDoc_14, res: any) => void): import("mongoose").Query<ResultDoc_14, ResultDoc_14, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndDelete<ResultDoc_15 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_15, res: any) => void): import("mongoose").Query<ResultDoc_15, ResultDoc_15, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndRemove<ResultDoc_16 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_16, res: any) => void): import("mongoose").Query<ResultDoc_16, ResultDoc_16, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_17 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_17>, ResultDoc_17, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_18 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_18, res: any) => void): import("mongoose").Query<ResultDoc_18, ResultDoc_18, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_19 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_19, res: any) => void): import("mongoose").Query<ResultDoc_19, ResultDoc_19, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_20 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_20>, ResultDoc_20, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_21 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_21, res: any) => void): import("mongoose").Query<ResultDoc_21, ResultDoc_21, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_22 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: {
            cID: string;
            for: string;
            name?: string;
        }, res: any) => void): import("mongoose").Query<ResultDoc_22, ResultDoc_22, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        geoSearch<ResultDoc_23 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").GeoSearchOptions, callback?: import("mongoose").Callback<ResultDoc_23[]>): import("mongoose").Query<ResultDoc_23[], ResultDoc_23, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        mapReduce<Key, Value>(o: import("mongoose").MapReduceOptions<{
            cID: string;
            for: string;
            name?: string;
        }, Key, Value>, callback?: import("mongoose").Callback<any>): Promise<any>;
        remove<ResultDoc_24 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_24, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        remove<ResultDoc_25 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, options?: import("mongoose").RemoveOptions, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_25, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        replaceOne<ResultDoc_26 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_26, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        schema: import("mongoose").Schema<{
            cID: string;
            for: string;
            name?: string;
        }, import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>;
        update<ResultDoc_27 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_27, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateMany<ResultDoc_28 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_28, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateOne<ResultDoc_29 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_29, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_30 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(path: string, val?: any): import("mongoose").Query<ResultDoc_30[], ResultDoc_30, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_31 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(obj: object): import("mongoose").Query<ResultDoc_31[], ResultDoc_31, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_32 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(): import("mongoose").Query<ResultDoc_32[], ResultDoc_32, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        on(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        once(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        off(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeAllListeners(event?: string | symbol): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        setMaxListeners(n: number): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        eventNames(): (string | symbol)[];
        discriminator<D>(name: string | number, schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            [x: string]: any;
        }>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): import("mongoose").Model<D, {}, {}, {}, any>;
        discriminator<T_3, U>(name: string | number, schema: import("mongoose").Schema<T_3, U, {}, {}, {}, {}, "type", import("mongoose").ObtainDocumentType<any, T_3, "type">>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): U;
        createIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        diffIndexes(options: Record<string, unknown>, callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(options?: Record<string, unknown>): Promise<import("mongoose").IndexesDiff>;
        ensureIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        listIndexes(callback: import("mongoose").Callback<any[]>): void;
        listIndexes(): Promise<any[]>;
        syncIndexes(options: import("mongoose").SyncIndexesOptions, callback: import("mongoose").Callback<string[]>): void;
        syncIndexes(options?: import("mongoose").SyncIndexesOptions): Promise<string[]>;
        startSession(options: import("mongodb").ClientSessionOptions, callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(options?: import("mongodb").ClientSessionOptions): Promise<import("mongodb").ClientSession>;
        get: (callback: any, limit: any) => void;
    }>;
}
declare class FreeGames {
    /**
     *
     * @param {_Client} client
     */
    constructor(client: _Client);
    client: _Client;
    update(): Promise<void>;
    channels: {
        new <DocType = {
            cID: string;
            for: string;
            name?: string;
        }>(doc?: DocType, fields?: any, options?: boolean | import("mongoose").AnyObject): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        aggregate<R = any>(pipeline?: import("mongoose").PipelineStage[], options?: import("mongodb").AggregateOptions, callback?: import("mongoose").Callback<R[]>): import("mongoose").Aggregate<R[]>;
        aggregate<R_1 = any>(pipeline: import("mongoose").PipelineStage[], callback?: import("mongoose").Callback<R_1[]>): import("mongoose").Aggregate<R_1[]>;
        base: typeof import("mongoose");
        baseModelName: string;
        castObject(obj: import("mongoose").AnyObject, options?: {
            ignoreCastErrors?: boolean;
        }): {
            cID: string;
            for: string;
            name?: string;
        };
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions, callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options?: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions): Promise<import("mongodb").BulkWriteResult>;
        bulkSave(documents: import("mongoose").Document<any, any, any>[], options?: import("mongodb").BulkWriteOptions & {
            timestamps?: boolean;
        }): Promise<import("mongodb").BulkWriteResult>;
        collection: import("mongoose").Collection<import("bson").Document>;
        count(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        count(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        create<DocContents = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents)[], options?: import("mongoose").SaveOptions): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_1 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_1)[], options?: import("mongoose").SaveOptions, callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_2 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_2)[], callback: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): void;
        create<DocContents_3 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_3): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        create<DocContents_4 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(...docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_4)[]): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_5 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_5, callback: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): void;
        createCollection<T extends import("bson").Document>(options: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">, callback: import("mongoose").Callback<import("mongodb").Collection<T>>): void;
        createCollection<T_1 extends import("bson").Document>(callback: import("mongoose").Callback<import("mongodb").Collection<T_1>>): void;
        createCollection<T_2 extends import("bson").Document>(options?: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">): Promise<import("mongodb").Collection<T_2>>;
        db: import("mongoose").Connection;
        deleteMany(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        events: NodeJS.EventEmitter;
        findById<ResultDoc = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc>): import("mongoose").Query<ResultDoc, ResultDoc, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findById<ResultDoc_1 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_1>): import("mongoose").Query<ResultDoc_1, ResultDoc_1, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_2 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_2>): import("mongoose").Query<ResultDoc_2, ResultDoc_2, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_3 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_3>): import("mongoose").Query<ResultDoc_3, ResultDoc_3, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_4 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_4>): import("mongoose").Query<ResultDoc_4, ResultDoc_4, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        hydrate(obj: any, projection?: import("mongoose").AnyObject, options?: {
            setters?: boolean;
        }): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        init(callback?: import("mongoose").CallbackWithoutResult): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        insertMany<DocContents_6 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_6)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_6>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_7 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_7)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_8 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_8)[], callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_8>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_9 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_9, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_9>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_10 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_10, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_11 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_11, options: import("mongoose").InsertManyOptions & {
            lean?: false;
        }, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_11>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_12 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_12, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_12>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_13 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_13)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_13>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_14 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_14)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_15 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_15)[]): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_15>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_16 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_16, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_16>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_17 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_17, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_18 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_18, options: import("mongoose").InsertManyOptions): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_18>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_19 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_19): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_19>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        modelName: string;
        populate(docs: any[], options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        populate(doc: any, options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        validate(callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, pathsToValidate: import("mongoose").PathsToValidate, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        watch<ResultType extends import("bson").Document = any>(pipeline?: Record<string, unknown>[], options?: import("mongodb").ChangeStreamOptions & {
            hydrate?: boolean;
        }): import("mongodb").ChangeStream<ResultType, import("mongodb").ChangeStreamDocument<ResultType>>;
        $where(argument: string | Function): import("mongoose").Query<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        discriminators: {
            [name: string]: import("mongoose").Model<any, {}, {}, {}, any>;
        };
        translateAliases(raw: any): any;
        distinct<ReturnType_1 = any>(field: string, filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<ReturnType_1[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        estimatedDocumentCount(options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").Callback<{
            _id: import("mongoose").Types.ObjectId;
        }>): import("mongoose").Query<Pick<import("mongoose").Document<{
            cID: string;
            for: string;
            name?: string;
        }, any, any>, "_id">, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>): import("mongoose").Query<{
            _id: import("mongoose").Types.ObjectId;
        }, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_5 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_5[]>): import("mongoose").Query<ResultDoc_5[], ResultDoc_5, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_6 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_6[]>): import("mongoose").Query<ResultDoc_6[], ResultDoc_6, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_7 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_7[]>): import("mongoose").Query<ResultDoc_7[], ResultDoc_7, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_8 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(callback?: import("mongoose").Callback<ResultDoc_8[]>): import("mongoose").Query<ResultDoc_8[], ResultDoc_8, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndDelete<ResultDoc_9 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_9, res: any) => void): import("mongoose").Query<ResultDoc_9, ResultDoc_9, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndRemove<ResultDoc_10 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_10, res: any) => void): import("mongoose").Query<ResultDoc_10, ResultDoc_10, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_11 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_11>, ResultDoc_11, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_12 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_12, res: any) => void): import("mongoose").Query<ResultDoc_12, ResultDoc_12, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_13 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_13, res: any) => void): import("mongoose").Query<ResultDoc_13, ResultDoc_13, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_14 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: (err: NativeError, doc: ResultDoc_14, res: any) => void): import("mongoose").Query<ResultDoc_14, ResultDoc_14, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndDelete<ResultDoc_15 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_15, res: any) => void): import("mongoose").Query<ResultDoc_15, ResultDoc_15, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndRemove<ResultDoc_16 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_16, res: any) => void): import("mongoose").Query<ResultDoc_16, ResultDoc_16, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_17 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_17>, ResultDoc_17, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_18 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_18, res: any) => void): import("mongoose").Query<ResultDoc_18, ResultDoc_18, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_19 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_19, res: any) => void): import("mongoose").Query<ResultDoc_19, ResultDoc_19, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_20 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_20>, ResultDoc_20, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_21 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_21, res: any) => void): import("mongoose").Query<ResultDoc_21, ResultDoc_21, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_22 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: {
            cID: string;
            for: string;
            name?: string;
        }, res: any) => void): import("mongoose").Query<ResultDoc_22, ResultDoc_22, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        geoSearch<ResultDoc_23 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").GeoSearchOptions, callback?: import("mongoose").Callback<ResultDoc_23[]>): import("mongoose").Query<ResultDoc_23[], ResultDoc_23, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        mapReduce<Key, Value>(o: import("mongoose").MapReduceOptions<{
            cID: string;
            for: string;
            name?: string;
        }, Key, Value>, callback?: import("mongoose").Callback<any>): Promise<any>;
        remove<ResultDoc_24 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_24, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        remove<ResultDoc_25 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, options?: import("mongoose").RemoveOptions, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_25, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        replaceOne<ResultDoc_26 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_26, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        schema: import("mongoose").Schema<{
            cID: string;
            for: string;
            name?: string;
        }, import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>;
        update<ResultDoc_27 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_27, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateMany<ResultDoc_28 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_28, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateOne<ResultDoc_29 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_29, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_30 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(path: string, val?: any): import("mongoose").Query<ResultDoc_30[], ResultDoc_30, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_31 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(obj: object): import("mongoose").Query<ResultDoc_31[], ResultDoc_31, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_32 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(): import("mongoose").Query<ResultDoc_32[], ResultDoc_32, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        on(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        once(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        off(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeAllListeners(event?: string | symbol): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        setMaxListeners(n: number): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        eventNames(): (string | symbol)[];
        discriminator<D>(name: string | number, schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            [x: string]: any;
        }>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): import("mongoose").Model<D, {}, {}, {}, any>;
        discriminator<T_3, U>(name: string | number, schema: import("mongoose").Schema<T_3, U, {}, {}, {}, {}, "type", import("mongoose").ObtainDocumentType<any, T_3, "type">>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): U;
        createIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        diffIndexes(options: Record<string, unknown>, callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(options?: Record<string, unknown>): Promise<import("mongoose").IndexesDiff>;
        ensureIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        listIndexes(callback: import("mongoose").Callback<any[]>): void;
        listIndexes(): Promise<any[]>;
        syncIndexes(options: import("mongoose").SyncIndexesOptions, callback: import("mongoose").Callback<string[]>): void;
        syncIndexes(options?: import("mongoose").SyncIndexesOptions): Promise<string[]>;
        startSession(options: import("mongodb").ClientSessionOptions, callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(options?: import("mongodb").ClientSessionOptions): Promise<import("mongodb").ClientSession>;
        get: (callback: any, limit: any) => void;
    };
    /**
     *
     * @param {channelM} channels
     */
    resolveChannels(channels: {
        new <DocType = {
            cID: string;
            for: string;
            name?: string;
        }>(doc?: DocType, fields?: any, options?: boolean | import("mongoose").AnyObject): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        aggregate<R = any>(pipeline?: import("mongoose").PipelineStage[], options?: import("mongodb").AggregateOptions, callback?: import("mongoose").Callback<R[]>): import("mongoose").Aggregate<R[]>;
        aggregate<R_1 = any>(pipeline: import("mongoose").PipelineStage[], callback?: import("mongoose").Callback<R_1[]>): import("mongoose").Aggregate<R_1[]>;
        base: typeof import("mongoose");
        baseModelName: string;
        castObject(obj: import("mongoose").AnyObject, options?: {
            ignoreCastErrors?: boolean;
        }): {
            cID: string;
            for: string;
            name?: string;
        };
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions, callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options?: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions): Promise<import("mongodb").BulkWriteResult>;
        bulkSave(documents: import("mongoose").Document<any, any, any>[], options?: import("mongodb").BulkWriteOptions & {
            timestamps?: boolean;
        }): Promise<import("mongodb").BulkWriteResult>;
        collection: import("mongoose").Collection<import("bson").Document>;
        count(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        count(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        create<DocContents = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents)[], options?: import("mongoose").SaveOptions): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_1 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_1)[], options?: import("mongoose").SaveOptions, callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_2 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_2)[], callback: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): void;
        create<DocContents_3 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_3): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        create<DocContents_4 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(...docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_4)[]): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_5 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_5, callback: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): void;
        createCollection<T extends import("bson").Document>(options: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">, callback: import("mongoose").Callback<import("mongodb").Collection<T>>): void;
        createCollection<T_1 extends import("bson").Document>(callback: import("mongoose").Callback<import("mongodb").Collection<T_1>>): void;
        createCollection<T_2 extends import("bson").Document>(options?: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">): Promise<import("mongodb").Collection<T_2>>;
        db: import("mongoose").Connection;
        deleteMany(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        events: NodeJS.EventEmitter;
        findById<ResultDoc = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc>): import("mongoose").Query<ResultDoc, ResultDoc, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findById<ResultDoc_1 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_1>): import("mongoose").Query<ResultDoc_1, ResultDoc_1, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_2 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_2>): import("mongoose").Query<ResultDoc_2, ResultDoc_2, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_3 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_3>): import("mongoose").Query<ResultDoc_3, ResultDoc_3, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_4 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_4>): import("mongoose").Query<ResultDoc_4, ResultDoc_4, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        hydrate(obj: any, projection?: import("mongoose").AnyObject, options?: {
            setters?: boolean;
        }): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        init(callback?: import("mongoose").CallbackWithoutResult): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        insertMany<DocContents_6 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_6)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_6>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_7 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_7)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_8 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_8)[], callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_8>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_9 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_9, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_9>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_10 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_10, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_11 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_11, options: import("mongoose").InsertManyOptions & {
            lean?: false;
        }, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_11>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_12 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_12, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_12>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_13 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_13)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_13>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_14 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_14)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_15 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_15)[]): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_15>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_16 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_16, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_16>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_17 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_17, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_18 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_18, options: import("mongoose").InsertManyOptions): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_18>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_19 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_19): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_19>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        modelName: string;
        populate(docs: any[], options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        populate(doc: any, options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        validate(callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, pathsToValidate: import("mongoose").PathsToValidate, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        watch<ResultType extends import("bson").Document = any>(pipeline?: Record<string, unknown>[], options?: import("mongodb").ChangeStreamOptions & {
            hydrate?: boolean;
        }): import("mongodb").ChangeStream<ResultType, import("mongodb").ChangeStreamDocument<ResultType>>;
        $where(argument: string | Function): import("mongoose").Query<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        discriminators: {
            [name: string]: import("mongoose").Model<any, {}, {}, {}, any>;
        };
        translateAliases(raw: any): any;
        distinct<ReturnType_1 = any>(field: string, filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<ReturnType_1[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        estimatedDocumentCount(options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").Callback<{
            _id: import("mongoose").Types.ObjectId;
        }>): import("mongoose").Query<Pick<import("mongoose").Document<{
            cID: string;
            for: string;
            name?: string;
        }, any, any>, "_id">, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>): import("mongoose").Query<{
            _id: import("mongoose").Types.ObjectId;
        }, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_5 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_5[]>): import("mongoose").Query<ResultDoc_5[], ResultDoc_5, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_6 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_6[]>): import("mongoose").Query<ResultDoc_6[], ResultDoc_6, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_7 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_7[]>): import("mongoose").Query<ResultDoc_7[], ResultDoc_7, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_8 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(callback?: import("mongoose").Callback<ResultDoc_8[]>): import("mongoose").Query<ResultDoc_8[], ResultDoc_8, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndDelete<ResultDoc_9 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_9, res: any) => void): import("mongoose").Query<ResultDoc_9, ResultDoc_9, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndRemove<ResultDoc_10 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_10, res: any) => void): import("mongoose").Query<ResultDoc_10, ResultDoc_10, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_11 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_11>, ResultDoc_11, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_12 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_12, res: any) => void): import("mongoose").Query<ResultDoc_12, ResultDoc_12, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_13 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_13, res: any) => void): import("mongoose").Query<ResultDoc_13, ResultDoc_13, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_14 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: (err: NativeError, doc: ResultDoc_14, res: any) => void): import("mongoose").Query<ResultDoc_14, ResultDoc_14, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndDelete<ResultDoc_15 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_15, res: any) => void): import("mongoose").Query<ResultDoc_15, ResultDoc_15, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndRemove<ResultDoc_16 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_16, res: any) => void): import("mongoose").Query<ResultDoc_16, ResultDoc_16, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_17 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_17>, ResultDoc_17, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_18 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_18, res: any) => void): import("mongoose").Query<ResultDoc_18, ResultDoc_18, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_19 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_19, res: any) => void): import("mongoose").Query<ResultDoc_19, ResultDoc_19, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_20 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_20>, ResultDoc_20, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_21 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_21, res: any) => void): import("mongoose").Query<ResultDoc_21, ResultDoc_21, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_22 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: {
            cID: string;
            for: string;
            name?: string;
        }, res: any) => void): import("mongoose").Query<ResultDoc_22, ResultDoc_22, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        geoSearch<ResultDoc_23 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").GeoSearchOptions, callback?: import("mongoose").Callback<ResultDoc_23[]>): import("mongoose").Query<ResultDoc_23[], ResultDoc_23, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        mapReduce<Key, Value>(o: import("mongoose").MapReduceOptions<{
            cID: string;
            for: string;
            name?: string;
        }, Key, Value>, callback?: import("mongoose").Callback<any>): Promise<any>;
        remove<ResultDoc_24 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_24, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        remove<ResultDoc_25 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, options?: import("mongoose").RemoveOptions, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_25, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        replaceOne<ResultDoc_26 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_26, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        schema: import("mongoose").Schema<{
            cID: string;
            for: string;
            name?: string;
        }, import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>;
        update<ResultDoc_27 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_27, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateMany<ResultDoc_28 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_28, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateOne<ResultDoc_29 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_29, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_30 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(path: string, val?: any): import("mongoose").Query<ResultDoc_30[], ResultDoc_30, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_31 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(obj: object): import("mongoose").Query<ResultDoc_31[], ResultDoc_31, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_32 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(): import("mongoose").Query<ResultDoc_32[], ResultDoc_32, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        on(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        once(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        off(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeAllListeners(event?: string | symbol): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        setMaxListeners(n: number): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        eventNames(): (string | symbol)[];
        discriminator<D>(name: string | number, schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            [x: string]: any;
        }>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): import("mongoose").Model<D, {}, {}, {}, any>;
        discriminator<T_3, U>(name: string | number, schema: import("mongoose").Schema<T_3, U, {}, {}, {}, {}, "type", import("mongoose").ObtainDocumentType<any, T_3, "type">>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): U;
        createIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        diffIndexes(options: Record<string, unknown>, callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(options?: Record<string, unknown>): Promise<import("mongoose").IndexesDiff>;
        ensureIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        listIndexes(callback: import("mongoose").Callback<any[]>): void;
        listIndexes(): Promise<any[]>;
        syncIndexes(options: import("mongoose").SyncIndexesOptions, callback: import("mongoose").Callback<string[]>): void;
        syncIndexes(options?: import("mongoose").SyncIndexesOptions): Promise<string[]>;
        startSession(options: import("mongodb").ClientSessionOptions, callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(options?: import("mongodb").ClientSessionOptions): Promise<import("mongodb").ClientSession>;
        get: (callback: any, limit: any) => void;
    }): Promise<{
        new <DocType = {
            cID: string;
            for: string;
            name?: string;
        }>(doc?: DocType, fields?: any, options?: boolean | import("mongoose").AnyObject): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        aggregate<R = any>(pipeline?: import("mongoose").PipelineStage[], options?: import("mongodb").AggregateOptions, callback?: import("mongoose").Callback<R[]>): import("mongoose").Aggregate<R[]>;
        aggregate<R_1 = any>(pipeline: import("mongoose").PipelineStage[], callback?: import("mongoose").Callback<R_1[]>): import("mongoose").Aggregate<R_1[]>;
        base: typeof import("mongoose");
        baseModelName: string;
        castObject(obj: import("mongoose").AnyObject, options?: {
            ignoreCastErrors?: boolean;
        }): {
            cID: string;
            for: string;
            name?: string;
        };
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions, callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], callback: import("mongoose").Callback<import("mongodb").BulkWriteResult>): void;
        bulkWrite(writes: import("mongodb").AnyBulkWriteOperation<{
            cID: string;
            for: string;
            name?: string;
        }>[], options?: import("mongodb").BulkWriteOptions & import("mongoose").MongooseBulkWriteOptions): Promise<import("mongodb").BulkWriteResult>;
        bulkSave(documents: import("mongoose").Document<any, any, any>[], options?: import("mongodb").BulkWriteOptions & {
            timestamps?: boolean;
        }): Promise<import("mongodb").BulkWriteResult>;
        collection: import("mongoose").Collection<import("bson").Document>;
        count(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        count(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        countDocuments(callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        create<DocContents = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents)[], options?: import("mongoose").SaveOptions): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_1 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_1)[], options?: import("mongoose").SaveOptions, callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_2 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_2)[], callback: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): void;
        create<DocContents_3 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_3): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        create<DocContents_4 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(...docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_4)[]): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        create<DocContents_5 = import("mongoose").AnyKeys<{
            cID: string;
            for: string;
            name?: string;
        }>>(doc: {
            cID: string;
            for: string;
            name?: string;
        } | DocContents_5, callback: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): void;
        createCollection<T extends import("bson").Document>(options: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">, callback: import("mongoose").Callback<import("mongodb").Collection<T>>): void;
        createCollection<T_1 extends import("bson").Document>(callback: import("mongoose").Callback<import("mongodb").Collection<T_1>>): void;
        createCollection<T_2 extends import("bson").Document>(options?: import("mongodb").CreateCollectionOptions & Pick<import("mongoose").SchemaOptions<"type", unknown, {}, {}, {}, {}>, "expires">): Promise<import("mongodb").Collection<T_2>>;
        db: import("mongoose").Connection;
        deleteMany(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteMany(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        deleteOne(callback: import("mongoose").CallbackWithoutResult): import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        events: NodeJS.EventEmitter;
        findById<ResultDoc = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc>): import("mongoose").Query<ResultDoc, ResultDoc, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findById<ResultDoc_1 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_1>): import("mongoose").Query<ResultDoc_1, ResultDoc_1, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_2 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_2>): import("mongoose").Query<ResultDoc_2, ResultDoc_2, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_3 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_3>): import("mongoose").Query<ResultDoc_3, ResultDoc_3, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOne<ResultDoc_4 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_4>): import("mongoose").Query<ResultDoc_4, ResultDoc_4, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        hydrate(obj: any, projection?: import("mongoose").AnyObject, options?: {
            setters?: boolean;
        }): import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        };
        init(callback?: import("mongoose").CallbackWithoutResult): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        insertMany<DocContents_6 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_6)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_6>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_7 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_7)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_8 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_8)[], callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_8>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_9 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_9, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }, callback: import("mongoose").Callback<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_9>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>): void;
        insertMany<DocContents_10 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_10, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }, callback: import("mongoose").Callback<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>): void;
        insertMany<DocContents_11 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_11, options: import("mongoose").InsertManyOptions & {
            lean?: false;
        }, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_11>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_12 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_12, callback: import("mongoose").Callback<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_12>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>): void;
        insertMany<DocContents_13 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_13)[], options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_13>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_14 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_14)[], options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_15 = {
            cID: string;
            for: string;
            name?: string;
        }>(docs: ({
            cID: string;
            for: string;
            name?: string;
        } | DocContents_15)[]): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_15>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_16 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_16, options: import("mongoose").InsertManyOptions & {
            lean: true;
        }): Promise<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_16>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>[]>;
        insertMany<DocContents_17 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_17, options: import("mongoose").InsertManyOptions & {
            rawResult: true;
        }): Promise<import("mongodb").InsertManyResult<{
            cID: string;
            for: string;
            name?: string;
        }>>;
        insertMany<DocContents_18 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_18, options: import("mongoose").InsertManyOptions): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_18>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        insertMany<DocContents_19 = {
            cID: string;
            for: string;
            name?: string;
        }>(doc: DocContents_19): Promise<import("mongoose").HydratedDocument<import("mongoose").MergeType<import("mongoose").MergeType<{
            cID: string;
            for: string;
            name?: string;
        }, DocContents_19>, {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>, {}, {}>[]>;
        modelName: string;
        populate(docs: any[], options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>): Promise<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[]>;
        populate(doc: any, options: string | import("mongoose").PopulateOptions | import("mongoose").PopulateOptions[], callback?: import("mongoose").Callback<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>): Promise<import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>;
        validate(callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        validate(optional: any, pathsToValidate: import("mongoose").PathsToValidate, callback?: import("mongoose").CallbackWithoutResult): Promise<void>;
        watch<ResultType extends import("bson").Document = any>(pipeline?: Record<string, unknown>[], options?: import("mongodb").ChangeStreamOptions & {
            hydrate?: boolean;
        }): import("mongodb").ChangeStream<ResultType, import("mongodb").ChangeStreamDocument<ResultType>>;
        $where(argument: string | Function): import("mongoose").Query<(import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        })[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        discriminators: {
            [name: string]: import("mongoose").Model<any, {}, {}, {}, any>;
        };
        translateAliases(raw: any): any;
        distinct<ReturnType_1 = any>(field: string, filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<ReturnType_1[], import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        estimatedDocumentCount(options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<number>): import("mongoose").Query<number, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: import("mongoose").Callback<{
            _id: import("mongoose").Types.ObjectId;
        }>): import("mongoose").Query<Pick<import("mongoose").Document<{
            cID: string;
            for: string;
            name?: string;
        }, any, any>, "_id">, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        exists(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>): import("mongoose").Query<{
            _id: import("mongoose").Types.ObjectId;
        }, import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_5 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_5[]>): import("mongoose").Query<ResultDoc_5[], ResultDoc_5, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_6 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, projection?: import("mongoose").ProjectionType<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_6[]>): import("mongoose").Query<ResultDoc_6[], ResultDoc_6, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_7 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<ResultDoc_7[]>): import("mongoose").Query<ResultDoc_7[], ResultDoc_7, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        find<ResultDoc_8 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(callback?: import("mongoose").Callback<ResultDoc_8[]>): import("mongoose").Query<ResultDoc_8[], ResultDoc_8, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndDelete<ResultDoc_9 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_9, res: any) => void): import("mongoose").Query<ResultDoc_9, ResultDoc_9, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndRemove<ResultDoc_10 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_10, res: any) => void): import("mongoose").Query<ResultDoc_10, ResultDoc_10, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_11 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_11>, ResultDoc_11, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_12 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_12, res: any) => void): import("mongoose").Query<ResultDoc_12, ResultDoc_12, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_13 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id?: any, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_13, res: any) => void): import("mongoose").Query<ResultDoc_13, ResultDoc_13, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findByIdAndUpdate<ResultDoc_14 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(id: any, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, callback: (err: NativeError, doc: ResultDoc_14, res: any) => void): import("mongoose").Query<ResultDoc_14, ResultDoc_14, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndDelete<ResultDoc_15 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_15, res: any) => void): import("mongoose").Query<ResultDoc_15, ResultDoc_15, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndRemove<ResultDoc_16 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_16, res: any) => void): import("mongoose").Query<ResultDoc_16, ResultDoc_16, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_17 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_17>, ResultDoc_17, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_18 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_18, res: any) => void): import("mongoose").Query<ResultDoc_18, ResultDoc_18, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndReplace<ResultDoc_19 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: ResultDoc_19, res: any) => void): import("mongoose").Query<ResultDoc_19, ResultDoc_19, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_20 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            rawResult: true;
        }, callback?: (err: NativeError, doc: any, res: any) => void): import("mongoose").Query<import("mongoose").ModifyResult<ResultDoc_20>, ResultDoc_20, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_21 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }> & {
            upsert: true;
        } & import("mongoose").ReturnsNewDoc, callback?: (err: NativeError, doc: ResultDoc_21, res: any) => void): import("mongoose").Query<ResultDoc_21, ResultDoc_21, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        findOneAndUpdate<ResultDoc_22 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: (err: NativeError, doc: {
            cID: string;
            for: string;
            name?: string;
        }, res: any) => void): import("mongoose").Query<ResultDoc_22, ResultDoc_22, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        geoSearch<ResultDoc_23 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").GeoSearchOptions, callback?: import("mongoose").Callback<ResultDoc_23[]>): import("mongoose").Query<ResultDoc_23[], ResultDoc_23, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        mapReduce<Key, Value>(o: import("mongoose").MapReduceOptions<{
            cID: string;
            for: string;
            name?: string;
        }, Key, Value>, callback?: import("mongoose").Callback<any>): Promise<any>;
        remove<ResultDoc_24 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_24, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        remove<ResultDoc_25 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: any, options?: import("mongoose").RemoveOptions, callback?: import("mongoose").CallbackWithoutResult): import("mongoose").Query<any, ResultDoc_25, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        replaceOne<ResultDoc_26 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, replacement?: import("mongoose").AnyObject | {
            cID: string;
            for: string;
            name?: string;
        }, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_26, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        schema: import("mongoose").Schema<{
            cID: string;
            for: string;
            name?: string;
        }, import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>;
        update<ResultDoc_27 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_27, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateMany<ResultDoc_28 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_28, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        updateOne<ResultDoc_29 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(filter?: import("mongoose").FilterQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<{
            cID: string;
            for: string;
            name?: string;
        }>, options?: import("mongoose").QueryOptions<{
            cID: string;
            for: string;
            name?: string;
        }>, callback?: import("mongoose").Callback<any>): import("mongoose").Query<import("mongodb").UpdateResult, ResultDoc_29, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_30 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(path: string, val?: any): import("mongoose").Query<ResultDoc_30[], ResultDoc_30, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_31 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(obj: object): import("mongoose").Query<ResultDoc_31[], ResultDoc_31, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        where<ResultDoc_32 = import("mongoose").Document<unknown, any, {
            cID: string;
            for: string;
            name?: string;
        }> & {
            cID: string;
            for: string;
            name?: string;
        } & {
            _id: import("mongoose").Types.ObjectId;
        }>(): import("mongoose").Query<ResultDoc_32[], ResultDoc_32, {}, {
            cID: string;
            for: string;
            name?: string;
        }>;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        on(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        once(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        off(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        removeAllListeners(event?: string | symbol): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        setMaxListeners(n: number): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): import("mongoose").Model<{
            cID: string;
            for: string;
            name?: string;
        }, {}, {}, {}, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            cID: string;
            for: string;
            name?: string;
        }>>;
        eventNames(): (string | symbol)[];
        discriminator<D>(name: string | number, schema: import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any>, {}, {}, {}, {}, "type", {
            [x: string]: any;
        }>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): import("mongoose").Model<D, {}, {}, {}, any>;
        discriminator<T_3, U>(name: string | number, schema: import("mongoose").Schema<T_3, U, {}, {}, {}, {}, "type", import("mongoose").ObtainDocumentType<any, T_3, "type">>, value?: string | number | import("mongoose").Schema.Types.ObjectId | import("mongoose").DiscriminatorOptions): U;
        createIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        createIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        diffIndexes(options: Record<string, unknown>, callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(callback: import("mongoose").Callback<import("mongoose").IndexesDiff>): void;
        diffIndexes(options?: Record<string, unknown>): Promise<import("mongoose").IndexesDiff>;
        ensureIndexes(options: import("mongodb").CreateIndexesOptions, callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(callback: import("mongoose").CallbackWithoutResult): void;
        ensureIndexes(options?: import("mongodb").CreateIndexesOptions): Promise<void>;
        listIndexes(callback: import("mongoose").Callback<any[]>): void;
        listIndexes(): Promise<any[]>;
        syncIndexes(options: import("mongoose").SyncIndexesOptions, callback: import("mongoose").Callback<string[]>): void;
        syncIndexes(options?: import("mongoose").SyncIndexesOptions): Promise<string[]>;
        startSession(options: import("mongodb").ClientSessionOptions, callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(callback: import("mongoose").Callback<import("mongodb").ClientSession>): void;
        startSession(options?: import("mongodb").ClientSessionOptions): Promise<import("mongodb").ClientSession>;
        get: (callback: any, limit: any) => void;
    }>;
}
import { ClientOptions } from "discord.js";
/**
 * Anilist Client -> Search Functions
 */
declare class AnimeInfo {
    /**
     *
     * @param {String} title
     * @param {String} status
     * @param {String} episodes
     * @param {String} trailer
     * @param {String} description
     * @param {String} coverImage
     */
    constructor(title: string, status: string, episodes: string, trailer: string, description: string, coverImage: string);
    title: string;
    status: string;
    episodes: string;
    trailer: string;
    description: string;
    coverImage: string;
}
declare class CharInfo {
    /**
     *
     * @param {String} name
     * @param {String} gender
     * @param {String} image
     * @param {String} description
     */
    constructor(name: string, gender: string, image: string, description: string);
    name: string;
    gender: string;
    image: string;
    description: string;
}
declare class MangaInfo {
    /**
     *
     * @param {String} title
     * @param {String} status
     * @param {String} description
     * @param {String} coverImage
     */
    constructor(title: string, status: string, description: string, coverImage: string);
    title: string;
    status: string;
    description: string;
    coverImage: string;
}
export { GatewayIntentBits, Partials, ActivityType, Message, command as Command, _Client as Client, AnilistCli as Anilist };
//# sourceMappingURL=lib.d.ts.map