@chevre/domain 28.0.0-alpha.9 → 28.1.0-alpha.0

package/lib/chevre/repo/adminAccountTitle.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAccountTitleRepo = void 0;
+const factory_1 = require("../factory");
+const accountTitle_1 = require("./mongoose/schemas/accountTitle");
+function createMatchStages(params) {
+    const matchStages = [];
+    const projectIdEq = params.project?.id?.$eq;
+    if (typeof projectIdEq === 'string') {
+        matchStages.push({
+            $match: { 'project.id': { $eq: projectIdEq } }
+        });
+    }
+    const nameRegex = params.name;
+    if (typeof nameRegex === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.hasCategoryCode.name': { $exists: true, $regex: new RegExp(nameRegex) } }
+        });
+    }
+    if (typeof params.codeValue === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $regex: new RegExp(params.codeValue) } }
+        });
+    }
+    else {
+        const codeValueEq = params.codeValue?.$eq;
+        if (typeof codeValueEq === 'string') {
+            matchStages.push({
+                $match: { 'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $eq: codeValueEq } }
+            });
+        }
+    }
+    const inCodeSetCodeValue = params.inCodeSet?.codeValue;
+    if (typeof inCodeSetCodeValue === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.codeValue': { $exists: true, $regex: new RegExp(inCodeSetCodeValue) } }
+        });
+    }
+    else {
+        const inCodeSetCodeValueEq = inCodeSetCodeValue?.$eq;
+        if (typeof inCodeSetCodeValueEq === 'string') {
+            matchStages.push({
+                $match: { 'hasCategoryCode.codeValue': { $exists: true, $eq: inCodeSetCodeValueEq } }
+            });
+        }
+    }
+    const accountTitleCategoryCode = params.inCodeSet?.inCodeSet?.codeValue;
+    if (typeof accountTitleCategoryCode === 'string') {
+        matchStages.push({
+            $match: { codeValue: { $exists: true, $regex: new RegExp(accountTitleCategoryCode) } }
+        });
+    }
+    else {
+        const accountTitleCategoryCodeEq = accountTitleCategoryCode?.$eq;
+        if (typeof accountTitleCategoryCodeEq === 'string') {
+            matchStages.push({
+                $match: { codeValue: { $exists: true, $eq: accountTitleCategoryCodeEq } }
+            });
+        }
+    }
+    const additionalPropertyElemMatch = params.additionalProperty?.$elemMatch;
+    if (additionalPropertyElemMatch !== undefined && additionalPropertyElemMatch !== null) {
+        matchStages.push({
+            $match: { 'hasCategoryCode.hasCategoryCode.additionalProperty': { $exists: true, $elemMatch: additionalPropertyElemMatch } }
+        });
+    }
+    return matchStages;
+}
+/**
+ * 細目管理リポジトリ
+ */
+class AdminAccountTitleRepo {
+    accountTitleModel;
+    constructor(connection) {
+        this.accountTitleModel = connection.model(accountTitle_1.modelName, (0, accountTitle_1.createSchema)());
+    }
+    async addAccountTitle(params) {
+        const { codeValue, name, project, inCodeSet, additionalProperty } = params;
+        // 科目の存在確認
+        const categoryDoc = await this.accountTitleModel.findOne({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: inCodeSet.codeValue }
+        }, { _id: 1 })
+            .exec();
+        if (categoryDoc === null) {
+            throw new factory_1.factory.errors.NotFound('AccountTitleSet');
+        }
+        const newAccountTitle = {
+            typeOf: 'AccountTitle',
+            codeValue,
+            additionalProperty: (Array.isArray(additionalProperty)) ? additionalProperty : [],
+            ...(typeof name === 'string') && { name }
+        };
+        // プロジェクト内での細目コード重複確認(インデックスは保証できない)
+        const existingAccountTitle = await this.accountTitleModel.findOne({
+            'project.id': { $eq: project.id },
+            // codeValue: { $eq: accountTitleCategory.codeValue },
+            // 'hasCategoryCode.codeValue': {
+            //     $exists: true,
+            //     $eq: accountTitleSet.codeValue
+            // },
+            'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $eq: codeValue }
+        }, { _id: 1 })
+            .exec();
+        if (existingAccountTitle !== null) {
+            throw new factory_1.factory.errors.AlreadyInUse(accountTitle_1.modelName, ['codeValue'], 'codeValue duplicated');
+        }
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.hasCategoryCode.codeValue': { $ne: codeValue }
+        }, {
+            $push: {
+                'hasCategoryCode.$[accountTitleSet].hasCategoryCode': newAccountTitle
+            }
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': inCodeSet.codeValue }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        // 存在しなければ細目コード重複
+        if (doc === null) {
+            throw new factory_1.factory.errors.AlreadyInUse(accountTitle_1.modelName, ['hasCategoryCode.hasCategoryCode.codeValue']);
+        }
+        return { id: doc.id };
+    }
+    async updateAccountTitle(params) {
+        const { codeValue, name, project, inCodeSet, additionalProperty } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.hasCategoryCode.codeValue': codeValue
+        }, {
+            // 'hasCategoryCode.$[accountTitleSet].hasCategoryCode.$[accountTitle].codeValue': accountTitle.codeValue,
+            ...(typeof name === 'string')
+                && { 'hasCategoryCode.$[accountTitleSet].hasCategoryCode.$[accountTitle].name': name },
+            ...(Array.isArray(additionalProperty))
+                && { 'hasCategoryCode.$[accountTitleSet].hasCategoryCode.$[accountTitle].additionalProperty': additionalProperty }
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': inCodeSet.codeValue },
+                { 'accountTitle.codeValue': codeValue }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+    async findAccountTitles(params) {
+        const aggregate = this.accountTitleModel.aggregate([
+            { $unwind: '$hasCategoryCode' },
+            { $unwind: '$hasCategoryCode.hasCategoryCode' },
+            ...createMatchStages(params),
+            {
+                $project: {
+                    _id: 0,
+                    codeValue: '$hasCategoryCode.hasCategoryCode.codeValue',
+                    name: '$hasCategoryCode.hasCategoryCode.name',
+                    inCodeSet: {
+                        codeValue: '$hasCategoryCode.codeValue',
+                        name: '$hasCategoryCode.name',
+                        inCodeSet: {
+                            codeValue: '$codeValue',
+                            name: '$name'
+                        },
+                    },
+                    additionalProperty: '$hasCategoryCode.hasCategoryCode.additionalProperty'
+                }
+            }
+        ]);
+        if (typeof params.limit === 'number' && typeof params.page === 'number') {
+            aggregate.skip(params.limit * (params.page - 1))
+                .limit(params.limit);
+        }
+        return aggregate.exec();
+    }
+    async deleteAccountTitleByCodeValue(params) {
+        const { projectId, codeValue, accountTitleCategoryCode, accountTitleSetCode } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: projectId },
+            codeValue: { $eq: accountTitleCategoryCode },
+            'hasCategoryCode.codeValue': { $exists: true, $eq: accountTitleSetCode },
+            'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $eq: codeValue }
+        }, {
+            $pull: {
+                'hasCategoryCode.$[accountTitleSet].hasCategoryCode': { codeValue }
+            }
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': accountTitleSetCode }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+}
+exports.AdminAccountTitleRepo = AdminAccountTitleRepo;

package/lib/chevre/repo/adminAccountTitleCategory.d.ts

@@ -0,0 +1,37 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+type IFindParams = Pick<factory.accountTitle.ISearchConditions, 'codeValue' | 'limit' | 'name' | 'page' | 'project' | 'sort'>;
+/**
+ * 科目分類管理リポジトリ
+ */
+export declare class AdminAccountTitleCategoryRepo {
+    private readonly accountTitleModel;
+    constructor(connection: Connection);
+    findAccountTitleCategorAsNotification(params: {
+        id: string;
+        projectId: string;
+    }): Promise<Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'hasCategoryCode' | 'name' | 'project' | 'typeOf'> & {
+        id: string;
+    }>;
+    deleteAccountTitleCategoriesByProject(params: {
+        project: {
+            id: string;
+        };
+    }): Promise<void>;
+    addAccountTitleCategory(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'>): Promise<{
+        id: string;
+    }>;
+    updateAccountTitleCategory(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'>): Promise<{
+        id: string;
+    }>;
+    findAccountTitleCategories(params: IFindParams): Promise<Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name'>[]>;
+    deleteAccountTitleCategoryByCodeValue(params: {
+        projectId: string;
+        codeValue: string;
+    }): Promise<void>;
+    unsetUnnecessaryFields(params: {
+        filter: any;
+        $unset: any;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+}
+export {};

package/lib/chevre/repo/adminAccountTitleCategory.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAccountTitleCategoryRepo = void 0;
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const accountTitle_1 = require("./mongoose/schemas/accountTitle");
+function createFilterQueries(params) {
+    const conditions = [];
+    const projectIdEq = params.project?.id?.$eq;
+    if (typeof projectIdEq === 'string') {
+        conditions.push({ 'project.id': { $eq: projectIdEq } });
+    }
+    if (typeof params.codeValue === 'string') {
+        conditions.push({ codeValue: { $exists: true, $regex: new RegExp(params.codeValue) } });
+    }
+    else {
+        const codeValueEq = params.codeValue?.$eq;
+        if (typeof codeValueEq === 'string') {
+            conditions.push({ codeValue: { $exists: true, $eq: codeValueEq } });
+        }
+    }
+    const nameRegex = params.name;
+    if (typeof nameRegex === 'string') {
+        conditions.push({ name: { $exists: true, $regex: new RegExp(nameRegex) } });
+    }
+    return conditions;
+}
+/**
+ * 科目分類管理リポジトリ
+ */
+class AdminAccountTitleCategoryRepo {
+    accountTitleModel;
+    constructor(connection) {
+        this.accountTitleModel = connection.model(accountTitle_1.modelName, (0, accountTitle_1.createSchema)());
+    }
+    async findAccountTitleCategorAsNotification(params) {
+        const { id, projectId } = params;
+        const doc = await this.accountTitleModel.findOne({
+            _id: { $eq: id },
+            'project.id': { $eq: projectId }
+        }, {
+            _id: 0,
+            id: { $toString: '$_id' },
+            codeValue: 1,
+            hasCategoryCode: 1,
+            name: 1,
+            project: 1,
+            typeOf: 1
+        })
+            .lean()
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound('AccountTitleCategory');
+        }
+        return doc;
+    }
+    async deleteAccountTitleCategoriesByProject(params) {
+        await this.accountTitleModel.deleteMany({
+            'project.id': { $exists: true, $eq: params.project.id }
+        })
+            .exec();
+    }
+    async addAccountTitleCategory(params) {
+        const { codeValue, name, project } = params;
+        const creatingAccountTitle = {
+            codeValue,
+            hasCategoryCode: [],
+            name,
+            project,
+            typeOf: 'AccountTitle'
+        };
+        const doc = await this.accountTitleModel.create(creatingAccountTitle);
+        return { id: doc.id };
+    }
+    async updateAccountTitleCategory(params) {
+        const { codeValue, name, project } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: codeValue }
+        }, {
+            $set: { name }
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+    async findAccountTitleCategories(params) {
+        const query = this.accountTitleModel.find({ $and: createFilterQueries(params) }, {
+            _id: 0,
+            codeValue: 1,
+            name: 1,
+        });
+        if (typeof params.limit === 'number' && typeof params.page === 'number') {
+            query.limit(params.limit)
+                .skip(params.limit * (params.page - 1));
+        }
+        if (typeof params.sort?.codeValue === 'number') {
+            query.sort({ codeValue: params.sort.codeValue });
+        }
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+    }
+    async deleteAccountTitleCategoryByCodeValue(params) {
+        const { projectId, codeValue } = params;
+        await this.accountTitleModel.findOneAndDelete({
+            'project.id': { $eq: projectId },
+            codeValue: { $eq: codeValue }
+        })
+            .exec()
+            .then((doc) => {
+            if (doc === null) {
+                throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+            }
+        });
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.accountTitleModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+}
+exports.AdminAccountTitleCategoryRepo = AdminAccountTitleCategoryRepo;

package/lib/chevre/repo/adminAccountTitleSet.d.ts

@@ -0,0 +1,42 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+type IFindParams = Pick<factory.accountTitle.ISearchConditions, 'codeValue' | 'limit' | 'name' | 'page' | 'project'> & {
+    inCodeSet?: {
+        codeValue?: string | {
+            $eq?: string;
+        };
+    };
+};
+type IAccountTitleSetAsFindResult = Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name'> & {
+    inCodeSet: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name'>;
+};
+/**
+ * 科目管理リポジトリ
+ */
+export declare class AdminAccountTitleSetRepo {
+    private readonly accountTitleModel;
+    constructor(connection: Connection);
+    addAccountTitleSet(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'> & {
+        inCodeSet: {
+            codeValue: string;
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    updateAccountTitleSet(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'> & {
+        inCodeSet: {
+            codeValue: string;
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    findAccountTitleSets(params: IFindParams): Promise<IAccountTitleSetAsFindResult[]>;
+    deleteAccountTitleSetByCodeValue(params: {
+        projectId: string;
+        accountTitleCategoryCode: string;
+        codeValue: string;
+    }): Promise<{
+        id: string;
+    }>;
+}
+export {};

package/lib/chevre/repo/adminAccountTitleSet.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAccountTitleSetRepo = void 0;
+const factory_1 = require("../factory");
+const accountTitle_1 = require("./mongoose/schemas/accountTitle");
+function createMatchStages(params) {
+    const matchStages = [];
+    if (typeof params.project?.id?.$eq === 'string') {
+        matchStages.push({ $match: { 'project.id': { $eq: params.project.id.$eq } } });
+    }
+    if (typeof params.codeValue === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.codeValue': { $exists: true, $regex: new RegExp(params.codeValue) } }
+        });
+    }
+    else if (params.codeValue !== undefined && params.codeValue !== null) {
+        if (typeof params.codeValue.$eq === 'string') {
+            matchStages.push({
+                $match: { 'hasCategoryCode.codeValue': { $exists: true, $eq: params.codeValue.$eq } }
+            });
+        }
+    }
+    if (params.inCodeSet !== undefined) {
+        if (typeof params.inCodeSet.codeValue === 'string') {
+            matchStages.push({
+                $match: { codeValue: { $exists: true, $regex: new RegExp(params.inCodeSet.codeValue) } }
+            });
+        }
+        else if (params.inCodeSet.codeValue !== undefined && params.inCodeSet.codeValue !== null) {
+            if (typeof params.inCodeSet.codeValue.$eq === 'string') {
+                matchStages.push({
+                    $match: { codeValue: { $exists: true, $eq: params.inCodeSet.codeValue.$eq } }
+                });
+            }
+        }
+    }
+    const nameRegex = params.name;
+    if (typeof nameRegex === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.name': { $exists: true, $regex: new RegExp(nameRegex) } }
+        });
+    }
+    return matchStages;
+}
+/**
+ * 科目管理リポジトリ
+ */
+class AdminAccountTitleSetRepo {
+    accountTitleModel;
+    constructor(connection) {
+        this.accountTitleModel = connection.model(accountTitle_1.modelName, (0, accountTitle_1.createSchema)());
+    }
+    async addAccountTitleSet(params) {
+        const { codeValue, name, project, inCodeSet } = params;
+        // 科目分類の存在確認
+        const categoryDoc = await this.accountTitleModel.findOne({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.codeValue }
+        }, { _id: 1 })
+            .exec();
+        if (categoryDoc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        const newAccountTitleSet = {
+            typeOf: 'AccountTitle',
+            codeValue,
+            hasCategoryCode: [],
+            ...(name !== undefined) && { name }
+        };
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $ne: codeValue }
+        }, {
+            $push: { hasCategoryCode: newAccountTitleSet }
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .exec();
+        // 存在しなければ科目コード重複
+        if (doc === null) {
+            throw new factory_1.factory.errors.AlreadyInUse(accountTitle_1.modelName, ['hasCategoryCode.codeValue']);
+        }
+        return { id: doc.id };
+    }
+    async updateAccountTitleSet(params) {
+        const { codeValue, name, project, inCodeSet } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: codeValue }
+        }, {
+            'hasCategoryCode.$[accountTitleSet].name': name,
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': codeValue }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+    async findAccountTitleSets(params) {
+        const aggregate = this.accountTitleModel.aggregate([
+            { $unwind: '$hasCategoryCode' },
+            ...createMatchStages(params),
+            {
+                $project: {
+                    _id: 0,
+                    codeValue: '$hasCategoryCode.codeValue',
+                    name: '$hasCategoryCode.name',
+                    inCodeSet: {
+                        codeValue: '$codeValue',
+                        name: '$name'
+                    },
+                }
+            }
+        ]);
+        if (typeof params.limit === 'number' && typeof params.page === 'number') {
+            aggregate.skip(params.limit * (params.page - 1))
+                .limit(params.limit);
+        }
+        return aggregate.exec();
+    }
+    async deleteAccountTitleSetByCodeValue(params) {
+        const { projectId, accountTitleCategoryCode, codeValue } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: projectId },
+            codeValue: { $eq: accountTitleCategoryCode },
+            'hasCategoryCode.codeValue': { $exists: true, $eq: codeValue }
+        }, {
+            $pull: { hasCategoryCode: { codeValue } }
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+}
+exports.AdminAccountTitleSetRepo = AdminAccountTitleSetRepo;

package/lib/chevre/repo/adminEvent.d.ts

@@ -100,7 +100,7 @@ export declare class AdminEventRepo {
         project: {
             id: string;
         };
-        superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'soundFormat' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
+        superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
         startDate: {
             $gte: Date;
         };

package/lib/chevre/repo/adminEventSeries.d.ts

@@ -40,28 +40,6 @@ export declare class AdminEventSeriesRepo {
         };
         id: string;
     }): Promise<void>;
-    /**
-     * 既存施設コンテンツの最大バージョンを集計する
-     */
-    aggregateMaxVersion(params: {
-        project: {
-            id: {
-                $eq: string;
-            };
-        };
-        workPerformed: {
-            identifier: {
-                $eq: string;
-            };
-        };
-        location: {
-            branchCode: {
-                $in: string[];
-            };
-        };
-    }): Promise<{
-        maxVersion: string;
-    }>;
     getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, factory.eventSeries.IAttributes & {
         _id: string;
     }, import("./mongoose/virtuals").IVirtuals, {}> & factory.eventSeries.IAttributes & {