@chevre/domain 25.2.0-alpha.5 → 25.2.0-alpha.50

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

@@ -1,5 +1,4 @@
-import type { BulkWriteResult } from 'mongodb';
-import { AnyExpression, Connection, Document, FilterQuery, PipelineStage } from 'mongoose';
+import { AnyExpression, Connection, Document, FilterQuery, PipelineStage, mongo } from 'mongoose';
 import { factory } from '../factory';
 import { IDocType as IAggregateOfferDocType } from './mongoose/schemas/aggregateOffer';
 type IMatchStage = PipelineStage.Match;
@@ -13,7 +12,7 @@ export declare class AggregateOfferRepo {
     constructor(connection: Connection);
     static CREATE_MATCH_STAGE(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): IMatchStage[];
     static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): Record<string, AnyExpression>;
-    search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<factory.aggregateOffer.IAggregateOffer[]>;
+    findAggregateOffers(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<Pick<factory.aggregateOffer.IAggregateOffer, 'id' | 'offers' | 'typeOf'>[]>;
     pushIncludedInDataCatalog(params: {
         project: {
             id: string;
@@ -80,7 +79,7 @@ export declare class AggregateOfferRepo {
          */
         productType: factory.product.ProductType;
     }): Promise<{
-        bulkWriteResult?: BulkWriteResult;
+        bulkWriteResult?: mongo.BulkWriteResult;
         modifiedOffers?: {
             id: string;
         }[];
@@ -110,15 +109,5 @@ export declare class AggregateOfferRepo {
             };
         };
     }): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
-    countIncludedInDataCatalog(params: {
-        id: {
-            $eq: string;
-        };
-    }): Promise<{
-        includedInDataCatalogCount: number;
-    }[]>;
-    maxIncludedInDataCatalogCount(): Promise<{
-        includedInDataCatalogCount: number;
-    }[]>;
 }
 export {};

package/lib/chevre/repo/aggregateOffer.js

@@ -374,11 +374,11 @@ class AggregateOfferRepo {
             _id: 0,
             id: '$_id',
             typeOf: '$typeOf',
-            project: '$project',
             offers: [{ $first: '$offers' }],
-            highPrice: { $max: '$offers.priceSpecification.price' },
-            lowPrice: { $min: '$offers.priceSpecification.price' },
-            offerCount: { $size: '$offers' }
+            // project: '$project', // discontinue(2026-07-24~)
+            // highPrice: { $max: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+            // lowPrice: { $min: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+            // offerCount: { $size: '$offers' } // offers.length:1に限定につき廃止(2026-07-24~)
         };
         const positiveProjectionFields = Object.keys(params)
             .filter((key) => params[key] !== 0);
@@ -389,11 +389,10 @@ class AggregateOfferRepo {
                 _id: 0,
                 id: '$_id',
                 typeOf: '$typeOf',
-                project: '$project',
-                // offers: [{ $first: '$offers' }],
-                highPrice: { $max: '$offers.priceSpecification.price' },
-                lowPrice: { $min: '$offers.priceSpecification.price' },
-                offerCount: { $size: '$offers' }
+                // project: '$project', // discontinue(2026-07-24~)
+                // highPrice: { $max: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+                // lowPrice: { $min: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+                // offerCount: { $size: '$offers' } // offers.length:1に限定につき廃止(2026-07-24~)
             };
             const offersProjection = {};
             positiveProjectionFields.forEach((field) => {
@@ -410,7 +409,7 @@ class AggregateOfferRepo {
         }
         return projectStage;
     }
-    async search(params, projection) {
+    async findAggregateOffers(params, projection) {
         const matchStages = AggregateOfferRepo.CREATE_MATCH_STAGE(params);
         const projectStage = AggregateOfferRepo.CREATE_AGGREGATE_OFFERS_PROJECTION({ ...projection });
         const sortByPrice = params.sort?.['priceSpecification.price'];
@@ -436,8 +435,11 @@ class AggregateOfferRepo {
         /* istanbul ignore else */
         if (typeof params.limit === 'number' && params.limit > 0) {
             const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
-            aggregate.limit(params.limit * page)
-                .skip(params.limit * (page - 1));
+            // support skip -> limit(2026-07-24~)
+            // aggregate.limit(params.limit * page)
+            //     .skip(params.limit * (page - 1));
+            aggregate.skip(params.limit * (page - 1))
+                .limit(params.limit);
         }
         return aggregate.exec();
     }
@@ -499,25 +501,6 @@ class AggregateOfferRepo {
         }, { projection: { _id: 1 } })
             .exec();
     }
-    // 単価オファー最適化作業における一時的な処理
-    // public async optimizeOffers() {
-    //     return this.aggregateOfferModel.updateMany(
-    //         {
-    //             $or: [
-    //                 { 'offers.id': { $exists: true } },
-    //                 { 'offers.project': { $exists: true } }
-    //             ]
-    //         },
-    //         {
-    //             $set: {},
-    //             $unset: {
-    //                 'offers.0.id': 1,
-    //                 'offers.0.project': 1
-    //             }
-    //         }
-    //     )
-    //         .exec();
-    // }
     getCursor(conditions, projection) {
         return this.aggregateOfferModel.find(conditions, projection)
             .sort({ 'offers.identifier': factory_1.factory.sortType.Ascending })
@@ -530,15 +513,12 @@ class AggregateOfferRepo {
     async save(params) {
         let doc;
         let aggregateOfferId;
-        // const { $unset, ...paramsWithoutUnset } = params;
         const { ...paramsWithoutUnset } = params;
-        // let savedUnitPriceOffer: factory.unitPriceOffer.IUnitPriceOffer;
         if (typeof params.id !== 'string' || params.id.length === 0) {
             const { default: uniqid } = await import('uniqid');
             const newId = uniqid();
             aggregateOfferId = newId;
             // サブオファー最適化(2023-12-22~)
-            // savedUnitPriceOffer = { ...paramsWithoutUnset, id };
             const { id, project, ...savedUnitPriceOffer } = paramsWithoutUnset; // eslint-disable-line @typescript-eslint/no-unused-vars
             const aggregateOffer = {
                 typeOf: factory_1.factory.offerType.AggregateOffer,
@@ -552,18 +532,7 @@ class AggregateOfferRepo {
         }
         else {
             aggregateOfferId = params.id;
-            // const unitPriceOffers = <Pick<factory.unitPriceOffer.IUnitPriceOffer, 'id' | 'identifier' | 'project' | 'typeOf'>[]>
-            //     await this.search(
-            //         {
-            //             limit: 1,
-            //             page: 1,
-            //             project: { id: { $eq: params.project.id } },
-            //             id: { $eq: params.id }
-            //         },
-            //         { identifier: 1, project: 1, typeOf: 1 }
-            //     );
-            // const originalUnitPriceOffer = unitPriceOffers.shift();
-            const aggregateOffers = await this.search({
+            const aggregateOffers = await this.findAggregateOffers({
                 limit: 1,
                 page: 1,
                 project: { id: { $eq: params.project.id } },
@@ -579,26 +548,17 @@ class AggregateOfferRepo {
             // サブオファー最適化(2023-12-22~)
             const subOffer = {
                 ...updateFields,
-                // id: originalUnitPriceOffer.id,
                 identifier: originalUnitPriceOffer.identifier,
-                // project: originalUnitPriceOffer.project,
                 typeOf: originalUnitPriceOffer.typeOf
             };
-            doc = await this.aggregateOfferModel.findOneAndUpdate(
-            // { 'offers.id': params.id },
-            { _id: params.id }, // _idに変更(2023-12-22~)
+            doc = await this.aggregateOfferModel.findOneAndUpdate({ _id: params.id }, // _idに変更(2023-12-22~)
             {
                 $set: {
-                    // 'offers.$[offer]': savedUnitPriceOffer
                     'offers.0': subOffer // _idに変更(2023-12-22~)
                 }
             }, {
                 upsert: false,
                 new: true
-                // _idに変更(2023-12-22~)
-                // arrayFilters: [
-                //     { 'offer.id': { $eq: params.id } }
-                // ]
             })
                 .exec();
         }
@@ -676,7 +636,6 @@ class AggregateOfferRepo {
     async saveManyByIdentifier4sskts(params) {
         const { default: uniqid } = await import('uniqid');
         const insertBulkWriteOps = [];
-        // const updateBulkWriteOps: AnyBulkWriteOperation[] = [];
         if (Array.isArray(params)) {
             params.forEach((p) => {
                 const newOfferId = uniqid();
@@ -710,7 +669,6 @@ class AggregateOfferRepo {
         }
         if (insertBulkWriteOps.length > 0) {
             await this.aggregateOfferModel.bulkWrite(insertBulkWriteOps, { ordered: false });
-            // await this.aggregateOfferModel.bulkWrite(updateBulkWriteOps, { ordered: false });
         }
     }
     /**
@@ -724,13 +682,6 @@ class AggregateOfferRepo {
             'project.id': { $eq: params.project.id },
             'offers.addOn.itemOffered.id': { $exists: true, $in: params.addOn.itemOffered.id.$in }
         };
-        // const updatingOffers = <Pick<factory.unitPriceOffer.IUnitPriceOffer, 'id' | 'identifier'>[]>await this.search(
-        //     {
-        //         project: { id: { $eq: params.project.id } },
-        //         addOn: { itemOffered: { id: { $in: params.addOn.itemOffered.id.$in } } }
-        //     },
-        //     { identifier: 1 }
-        // );
         return this.aggregateOfferModel.updateMany(conditions, {
             $pull: {
                 'offers.$[offer].addOn': {
@@ -743,66 +694,6 @@ class AggregateOfferRepo {
             ]
         })
             .exec();
-        // if (updatingOffers.length > 0) {
-        //     // no op
-        // }
-        // return result;
-    }
-    async countIncludedInDataCatalog(params) {
-        const aggregate = this.aggregateOfferModel.aggregate([
-            {
-                $match: {
-                    _id: { $eq: params.id.$eq }
-                }
-            },
-            {
-                $project: {
-                    _id: 0,
-                    includedInDataCatalogCount: {
-                        $cond: {
-                            if: { $isArray: '$includedInDataCatalog' },
-                            then: { $size: '$includedInDataCatalog' },
-                            else: 0
-                        }
-                    }
-                }
-            }
-        ]);
-        return aggregate.exec();
-    }
-    async maxIncludedInDataCatalogCount() {
-        const aggregate = this.aggregateOfferModel.aggregate([
-            // {
-            //     $match: {
-            //         _id: { $eq: params.id.$eq }
-            //     }
-            // },
-            {
-                $project: {
-                    _id: 0,
-                    includedInDataCatalogCount: {
-                        $cond: {
-                            if: { $isArray: '$includedInDataCatalog' },
-                            then: { $size: '$includedInDataCatalog' },
-                            else: 0
-                        }
-                    }
-                }
-            },
-            {
-                $group: {
-                    _id: null,
-                    maxCount: { $max: '$includedInDataCatalogCount' }
-                }
-            },
-            {
-                $project: {
-                    _id: 0,
-                    maxCount: '$maxCount'
-                }
-            }
-        ]);
-        return aggregate.exec();
     }
 }
 exports.AggregateOfferRepo = AggregateOfferRepo;

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

@@ -0,0 +1,64 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+import { IModel, IDocType } from './mongoose/schemas/asyncAction';
+import type { IExecutableTask } from '../taskSettings';
+type ISavingTask = Pick<factory.task.IAttributes<factory.taskName>, 'data' | 'executionResults' | 'expires' | 'name' | 'project' | 'runsAt' | 'status'> & {
+    expires: Date;
+};
+export type IExecutableAsyncAction = Pick<IExecutableTask<factory.taskName>, 'data' | 'expires' | 'id' | 'name' | 'project' | 'runsAt' | 'status'>;
+type IKeyOfProjection = keyof factory.task.ITask<factory.taskName>;
+/**
+ * 非同期アクションリポジトリ
+ */
+export declare class AsyncActionRepo {
+    readonly asyncActionModel: IModel;
+    constructor(connection: Connection);
+    /**
+     * Readyタスクをひとつ追加する
+     */
+    addReadyAsyncAction(params: Pick<ISavingTask, 'data' | 'expires' | 'name' | 'project' | 'runsAt'> & {
+        alternateName?: never;
+        identifier?: never;
+    }): Promise<{
+        id: string;
+    }>;
+    /**
+     * Ready -> Running
+     */
+    executeAsyncActionById(params: {
+        id: string;
+        executor: {
+            name: string;
+        };
+    }): Promise<IExecutableAsyncAction | null>;
+    /**
+     * 非同期アクションの状態を参照する
+     */
+    findAsyncActionById(params: {
+        id: {
+            $eq: string;
+        };
+        project: {
+            id: {
+                $eq: string;
+            };
+        };
+        name: factory.taskName;
+    }, inclusion: IKeyOfProjection[]): Promise<(IDocType & {
+        id: string;
+    } | undefined)>;
+    /**
+     * タスクIDから実行結果とステータスを保管する
+     * Abortedの場合、dateAbortedもセットする
+     */
+    setExecutionResultAndStatus(params: {
+        /**
+         * タスクID
+         */
+        id: string;
+    }, update: {
+        status: factory.taskStatus.Executed | factory.taskStatus.Aborted;
+        executionResult: factory.task.IExecutionResult;
+    }): Promise<void>;
+}
+export {};

package/lib/chevre/repo/asyncAction.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncActionRepo = void 0;
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const asyncAction_1 = require("./mongoose/schemas/asyncAction");
+const executableTaskProjection = {
+    _id: 0,
+    id: { $toString: '$_id' },
+    // 必要最低限にprojection(2024-04-23~)
+    data: 1,
+    name: 1,
+    status: 1,
+    project: 1,
+    runsAt: 1,
+    expires: 1
+};
+const AVAILABLE_PROJECT_FIELDS = [
+    'project',
+    'name',
+    'status',
+    'runsAt',
+    'lastTriedAt',
+    'executionResults',
+    'executor',
+    'data',
+    'dateAborted',
+    'expires'
+];
+/**
+ * 非同期アクションリポジトリ
+ */
+class AsyncActionRepo {
+    asyncActionModel;
+    constructor(connection) {
+        this.asyncActionModel = connection.model(asyncAction_1.modelName, (0, asyncAction_1.createSchema)());
+    }
+    /**
+     * Readyタスクをひとつ追加する
+     */
+    async addReadyAsyncAction(params) {
+        const { expires } = params;
+        if (!(expires instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('expires', 'must be Date');
+        }
+        const savingTask = {
+            ...params,
+            status: factory_1.factory.taskStatus.Ready,
+            executionResults: []
+        };
+        const result = await this.asyncActionModel.insertMany(savingTask, { rawResult: true });
+        const id = result.insertedIds?.[0]?.toHexString();
+        if (typeof id !== 'string') {
+            throw new factory_1.factory.errors.Internal('task not saved');
+        }
+        return { id };
+    }
+    /**
+     * Ready -> Running
+     */
+    async executeAsyncActionById(params) {
+        const now = new Date();
+        const doc = await this.asyncActionModel.findOneAndUpdate({
+            _id: { $eq: params.id },
+            status: { $eq: factory_1.factory.taskStatus.Ready }, // Readyのものしか実行しない
+            runsAt: { $lt: now },
+            expires: { $gt: now }, // ワンタイムタスクなのでexpiresは必ず存在する
+        }, {
+            $set: {
+                status: factory_1.factory.taskStatus.Running, // 実行中に変更
+                lastTriedAt: now,
+                executor: params.executor
+            },
+        }, { new: true, projection: executableTaskProjection })
+            .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean() // lean(2024-09-26~)
+            .exec();
+        if (doc === null) {
+            return null;
+        }
+        return doc;
+    }
+    /**
+     * 非同期アクションの状態を参照する
+     */
+    async findAsyncActionById(params, inclusion) {
+        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = inclusion.filter((key) => AVAILABLE_PROJECT_FIELDS.includes(key));
+        }
+        else {
+            // no op
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const query = this.asyncActionModel.findOne({
+            _id: { $eq: params.id.$eq },
+            'project.id': { $eq: params.project.id.$eq },
+            name: { $eq: params.name }
+        }, projection);
+        const doc = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+        if (doc === null) {
+            return;
+        }
+        return doc;
+    }
+    // /**
+    //  * Readyのままで期限切れのタスクをExpiredに変更する
+    //  */
+    // public async makeExpiredMany(params: {
+    //     expiresLt: Date;
+    // }): Promise<UpdateWriteOpResult> {
+    //     const { expiresLt } = params;
+    //     if (!(expiresLt instanceof Date)) {
+    //         throw new factory.errors.Argument('expiresLt', 'must be Date');
+    //     }
+    //     return this.asyncActionModel.updateMany(
+    //         {
+    //             status: { $eq: factory.taskStatus.Ready },
+    //             expires: { $lt: expiresLt }
+    //         },
+    //         {
+    //             $set: {
+    //                 status: factory.taskStatus.Expired
+    //             }
+    //         }
+    //     )
+    //         .exec();
+    // }
+    // /**
+    //  * taskNameに関わらず、Runningのまま放置された非同期アクションをAbortedに変更する
+    //  */
+    // public async abortMany(params: {
+    //     intervalInMinutes: number;
+    // }): Promise<UpdateWriteOpResult> {
+    //     const lastTriedAtShoudBeLessThan = moment()
+    //         .add(-params.intervalInMinutes, 'minutes')
+    //         .toDate();
+    //     return this.asyncActionModel.updateMany(
+    //         {
+    //             status: { $eq: factory.taskStatus.Running },
+    //             lastTriedAt: {
+    //                 $exists: true,
+    //                 $lt: lastTriedAtShoudBeLessThan
+    //             }
+    //         },
+    //         {
+    //             $set: {
+    //                 status: factory.taskStatus.Aborted,
+    //                 dateAborted: new Date()
+    //             }
+    //         }
+    //     )
+    //         .exec();
+    // }
+    /**
+     * タスクIDから実行結果とステータスを保管する
+     * Abortedの場合、dateAbortedもセットする
+     */
+    async setExecutionResultAndStatus(params, update) {
+        const { id } = params;
+        const { status, executionResult } = update;
+        await this.asyncActionModel.updateOne({ _id: { $eq: id } }, {
+            $set: {
+                status,
+                ...(status === factory_1.factory.taskStatus.Aborted) ? { dateAborted: executionResult.endDate } : undefined // 2025-08-04~
+            },
+            $push: { executionResults: executionResult }
+        })
+            .exec();
+    }
+}
+exports.AsyncActionRepo = AsyncActionRepo;

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

@@ -1,5 +1,6 @@
-import type { RedisClientType } from 'redis';
+import type { createClient } from 'redis';
 import { AbstractConcurrentLockRepo, ILockParams, IUnlockParams } from './concurrentLockAbstract';
+type RedisClientType = ReturnType<typeof createClient>;
 /**
  * 同時実行ロックリポジトリ
  */
@@ -12,3 +13,4 @@ export declare class ConcurrentLockRepo implements AbstractConcurrentLockRepo {
     lock(params: ILockParams): Promise<void>;
     unlock(params: IUnlockParams): Promise<void>;
 }
+export {};

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

@@ -1,5 +1,4 @@
-import type { BulkWriteResult } from 'mongodb';
-import { Connection, FilterQuery, Types } from 'mongoose';
+import { Connection, FilterQuery, Types, mongo } from 'mongoose';
 import { factory } from '../factory';
 import { IDocType } from './mongoose/schemas/creativeWork';
 type IKeyOfProjection = keyof factory.creativeWork.movie.ICreativeWork;
@@ -32,7 +31,7 @@ export declare class CreativeWorkRepo {
             [key in keyof factory.creativeWork.movie.ICreativeWork]?: 1;
         };
     }[]): Promise<{
-        bulkWriteResult?: BulkWriteResult;
+        bulkWriteResult?: mongo.BulkWriteResult;
     }>;
     /**
      * コンテンツを検索する

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

@@ -1,9 +1,10 @@
 import type { COA } from '@motionpicture/coa-service';
-import type { RedisClientType } from 'redis';
+import type { createClient } from 'redis';
 interface IOptions {
     scope: string;
     expireInSeconds: number;
 }
+type RedisClientType = ReturnType<typeof createClient>;
 /**
  * 認証情報リポジトリ
  */

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

@@ -1,5 +1,4 @@
-import type { BulkWriteResult } from 'mongodb';
-import { Connection, FilterQuery } from 'mongoose';
+import type { Connection, FilterQuery, mongo } from 'mongoose';
 import { ICustomerType } from './mongoose/schemas/customerType';
 import { factory } from '../factory';
 type IKeyOfProjection = keyof ICustomerType;
@@ -17,6 +16,6 @@ export declare class CustomerTypeRepo {
     saveManyByCodeValue(params: {
         attributes: ICustomerType;
         upsert?: boolean;
-    }[]): Promise<BulkWriteResult | undefined>;
+    }[]): Promise<mongo.BulkWriteResult | undefined>;
 }
 export {};

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

@@ -1,5 +1,4 @@
-import type { BulkWriteResult } from 'mongodb';
-import { Connection, FilterQuery } from 'mongoose';
+import { Connection, FilterQuery, mongo } from 'mongoose';
 import { factory } from '../factory';
 import * as EventFactory from '../factory/event';
 export interface IAttributes4patchUpdate {
@@ -83,7 +82,7 @@ export declare class EventRepo {
          */
         update: boolean;
     }): Promise<{
-        bulkWriteResult?: BulkWriteResult;
+        bulkWriteResult?: mongo.BulkWriteResult;
         modifiedEvents: {
             id: string;
         }[];
@@ -202,7 +201,7 @@ export declare class EventRepo {
         organizer: {
             id: string;
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     deleteManyEventsByScreeningRoom(params: {
         project: {
             id: string;
@@ -219,7 +218,7 @@ export declare class EventRepo {
                 id: string;
             };
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     deleteManyBySuperEventId(params: {
         project: {
             id: string;
@@ -227,7 +226,7 @@ export declare class EventRepo {
         superEvent: {
             id: string;
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     deleteManyBySuperEventLocationId(params: {
         project: {
             id: string;
@@ -237,7 +236,7 @@ export declare class EventRepo {
                 id: string;
             };
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     /**
      * 興行(プロダクト)から削除する
      */
@@ -252,7 +251,7 @@ export declare class EventRepo {
                 };
             };
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     deleteManyEventsEndedByProject(params: {
         typeOf: {
             $in: factory.eventType.ScreeningEvent[];
@@ -263,7 +262,7 @@ export declare class EventRepo {
         endDate: {
             $lte: Date;
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     deleteManyEventsEnded(params: {
         typeOf: {
             $eq: factory.eventType.ScreeningEvent;
@@ -271,7 +270,7 @@ export declare class EventRepo {
         endDate: {
             $lte: Date;
         };
-    }): Promise<import("mongodb").DeleteResult>;
+    }): Promise<mongo.DeleteResult>;
     deleteByProject(params: {
         project: {
             id: string;
@@ -283,7 +282,7 @@ export declare class EventRepo {
     updateAggregationById(params: {
         id: string;
     }, update: IUpdateAggregateReservationParams): Promise<void>;
-    bulkWrite(bulkWriteOps: any[]): Promise<BulkWriteResult & {
+    bulkWrite(bulkWriteOps: any[]): Promise<mongo.BulkWriteResult & {
         mongoose?: {
             validationErrors: import("mongoose").Error[];
         } | undefined;