@chevre/domain 26.0.0-alpha.25 → 26.0.0-alpha.26

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

@@ -0,0 +1,132 @@
+import type { Connection, FilterQuery } from 'mongoose';
+import { IDocType } from './mongoose/schemas/assetTransaction';
+import { factory } from '../factory';
+type AvailableAssetTransactionType = factory.assetTransactionType.CancelReservation | factory.assetTransactionType.Pay | factory.assetTransactionType.Refund | factory.assetTransactionType.Reserve;
+/**
+ * 資産取引管理リポジトリ
+ */
+export declare class AdminAssetTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    static CREATE_MONGO_CONDITIONS(params: factory.assetTransaction.ISearchConditions<factory.assetTransactionType>): FilterQuery<import("@chevre/factory/lib/chevre/assetTransaction/cancelReservation").ITransaction | import("@chevre/factory/lib/chevre/assetTransaction/pay").ITransaction | import("@chevre/factory/lib/chevre/assetTransaction/refund").ITransaction | import("@chevre/factory/lib/chevre/assetTransaction/reserve").ITransaction>[];
+    countPotentiallyExportTasks(params: {
+        endDate: {
+            $lt: Date;
+        };
+        limit?: number;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * tasksExportAction.actionStatusがActiveActionStatusのまま一定時間経過した取引について
+     * PotentialActionStatusに変更する
+     * 2025-03-10~
+     */
+    reExportAction(params: {
+        startDate: {
+            $lt: Date;
+        };
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+    /**
+     * add(2025-03-17~)
+     */
+    countPotentiallyExpired(params: {
+        expires: {
+            $lt: Date;
+        };
+        limit?: number;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * add(2025-03-12~)
+     */
+    makeOneExpiredIfExists(params: {
+        expires: {
+            $lt: Date;
+        };
+    }): Promise<Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'id' | 'typeOf'> | undefined>;
+    countAssetTransactions<T extends factory.assetTransactionType>(params: factory.assetTransaction.ISearchConditions<T>): Promise<{
+        count: number;
+    }>;
+    /**
+     * 取引を検索する
+     */
+    findAssetTransactions<T extends AvailableAssetTransactionType>(params: factory.assetTransaction.ISearchConditions<T>, inclusion?: string[], exclusion?: string[]): Promise<factory.assetTransaction.ITransaction<T>[]>;
+    /**
+     * 終了日時を一定期間過ぎたアクションを削除する
+     */
+    deleteEndDatePassedCertainPeriod(params: {
+        $lt: Date;
+    }): Promise<import("mongodb").DeleteResult>;
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & ((import("@chevre/factory/lib/chevre/assetTransaction/cancelReservation").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | (import("@chevre/factory/lib/chevre/assetTransaction/pay").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | (import("@chevre/factory/lib/chevre/assetTransaction/refund").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | (import("@chevre/factory/lib/chevre/assetTransaction/reserve").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    })), import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & ((import("@chevre/factory/lib/chevre/assetTransaction/cancelReservation").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | (import("@chevre/factory/lib/chevre/assetTransaction/pay").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | (import("@chevre/factory/lib/chevre/assetTransaction/refund").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | (import("@chevre/factory/lib/chevre/assetTransaction/reserve").IAttributes & {
+        id: string;
+    } & {
+        seller?: any;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }))) | null>;
+    unsetUnnecessaryFields(params: {
+        filter: any;
+        $unset: any;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+}
+export {};

package/lib/chevre/repo/adminAssetTransaction.js

@@ -0,0 +1,504 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAssetTransactionRepo = void 0;
+const assetTransaction_1 = require("./mongoose/schemas/assetTransaction");
+const factory_1 = require("../factory");
+const assetTransaction_2 = require("../eventEmitter/assetTransaction");
+const settings_1 = require("../settings");
+/**
+ * 資産取引管理リポジトリ
+ */
+class AdminAssetTransactionRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(assetTransaction_1.modelName, (0, assetTransaction_1.createSchema)());
+    }
+    static CREATE_MONGO_CONDITIONS(params) {
+        const andConditions = [
+            { typeOf: { $eq: params.typeOf } }
+        ];
+        const projectIdEq = params.project?.id?.$eq;
+        /* istanbul ignore else */
+        if (typeof projectIdEq === 'string') {
+            andConditions.push({ 'project.id': { $eq: projectIdEq } });
+        }
+        /* istanbul ignore else */
+        if (params.startFrom !== undefined) {
+            andConditions.push({
+                startDate: { $gte: params.startFrom }
+            });
+        }
+        /* istanbul ignore else */
+        if (params.startThrough !== undefined) {
+            andConditions.push({
+                startDate: { $lte: params.startThrough }
+            });
+        }
+        /* istanbul ignore else */
+        if (params.endFrom !== undefined) {
+            andConditions.push({
+                endDate: {
+                    $exists: true,
+                    $gte: params.endFrom
+                }
+            });
+        }
+        /* istanbul ignore else */
+        if (params.endThrough !== undefined) {
+            andConditions.push({
+                endDate: {
+                    $exists: true,
+                    $lt: params.endThrough
+                }
+            });
+        }
+        /* istanbul ignore else */
+        if (Array.isArray(params.ids)) {
+            andConditions.push({
+                _id: { $in: params.ids }
+            });
+        }
+        /* istanbul ignore else */
+        if (Array.isArray(params.statuses)) {
+            andConditions.push({ status: { $in: params.statuses } });
+        }
+        /* istanbul ignore else */
+        const statusIn = params.status?.$in;
+        if (Array.isArray(statusIn)) {
+            andConditions.push({ status: { $in: statusIn } });
+        }
+        /* istanbul ignore else */
+        if (params.agent !== undefined) {
+            if (Array.isArray(params.agent.ids)) {
+                andConditions.push({
+                    'agent.id': { $in: params.agent.ids }
+                });
+            }
+        }
+        const transactionNumberEq = params.transactionNumber?.$eq;
+        if (typeof transactionNumberEq === 'string') {
+            andConditions.push({ transactionNumber: { $eq: transactionNumberEq } });
+        }
+        const transactionNumberIn = params.transactionNumber?.$in;
+        if (Array.isArray(transactionNumberIn)) {
+            andConditions.push({ transactionNumber: { $in: transactionNumberIn } });
+        }
+        const tasksExportActionStatusIn = params.tasksExportAction?.actionStatus?.$in;
+        /* istanbul ignore else */
+        if (Array.isArray(tasksExportActionStatusIn)) {
+            andConditions.push({ 'tasksExportAction.actionStatus': { $exists: true, $in: tasksExportActionStatusIn } });
+        }
+        const tasksExportActionStatusEq = params.tasksExportAction?.actionStatus?.$eq;
+        /* istanbul ignore else */
+        if (typeof tasksExportActionStatusEq === 'string') {
+            andConditions.push({ 'tasksExportAction.actionStatus': { $exists: true, $eq: tasksExportActionStatusEq } });
+        }
+        switch (params.typeOf) {
+            case factory_1.factory.assetTransactionType.Pay: {
+                const objectAccountIdEq = params.object?.accountId?.$eq;
+                if (typeof objectAccountIdEq === 'string') {
+                    andConditions.push({ 'object.accountId': { $exists: true, $eq: objectAccountIdEq } });
+                }
+                const objectTypeOfEq = params.object?.typeOf?.$eq;
+                if (typeof objectTypeOfEq === 'string') {
+                    andConditions.push({ 'object.typeOf': { $exists: true, $eq: objectTypeOfEq } });
+                }
+                break;
+            }
+            case factory_1.factory.assetTransactionType.Refund: {
+                const objectAccountIdEq4refund = params.object?.accountId?.$eq;
+                if (typeof objectAccountIdEq4refund === 'string') {
+                    andConditions.push({
+                        'object.accountId': {
+                            $exists: true,
+                            $eq: objectAccountIdEq4refund
+                        }
+                    });
+                }
+                const objectPaymentMethodIdEq4refund = params.object?.paymentMethodId?.$eq;
+                if (typeof objectPaymentMethodIdEq4refund === 'string') {
+                    andConditions.push({
+                        'object.paymentMethodId': { $exists: true, $eq: objectPaymentMethodIdEq4refund }
+                    });
+                }
+                const objectPaymentMethodIdIn4refund = params.object?.paymentMethodId?.$in;
+                if (Array.isArray(objectPaymentMethodIdIn4refund)) {
+                    andConditions.push({
+                        'object.paymentMethodId': { $exists: true, $in: objectPaymentMethodIdIn4refund }
+                    });
+                }
+                break;
+            }
+            case factory_1.factory.assetTransactionType.CancelReservation: {
+                const objectReservationNumberIn4cancelReservation = params.object?.reservationNumber?.$in;
+                if (Array.isArray(objectReservationNumberIn4cancelReservation)) {
+                    andConditions.push({
+                        'object.reservationNumber': { $exists: true, $in: objectReservationNumberIn4cancelReservation }
+                    });
+                }
+                const objectReservationNumberEq4cancelReservation = params.object?.reservationNumber?.$eq;
+                if (typeof objectReservationNumberEq4cancelReservation === 'string') {
+                    andConditions.push({
+                        'object.reservationNumber': { $exists: true, $eq: objectReservationNumberEq4cancelReservation }
+                    });
+                }
+                break;
+            }
+            case factory_1.factory.assetTransactionType.Reserve: {
+                // discontinue(2026-08-10~)
+                // const objectProviderIdEq = params.object?.provider?.id?.$eq;
+                // if (typeof objectProviderIdEq === 'string') {
+                //     andConditions.push({ 'object.provider.id': { $exists: true, $eq: objectProviderIdEq } });
+                // }
+                const objectReservationForIdEq = params.object?.reservationFor?.id?.$eq;
+                if (typeof objectReservationForIdEq === 'string') {
+                    andConditions.push({
+                        'object.reservationFor.id': {
+                            $exists: true,
+                            $eq: objectReservationForIdEq
+                        }
+                    });
+                }
+                const objectReservationNumberIn = params.object?.reservationNumber?.$in;
+                if (Array.isArray(objectReservationNumberIn)) {
+                    andConditions.push({
+                        'object.reservationNumber': { $exists: true, $in: objectReservationNumberIn }
+                    });
+                }
+                const objectReservationNumberEq = params.object?.reservationNumber?.$eq;
+                if (typeof objectReservationNumberEq === 'string') {
+                    andConditions.push({
+                        'object.reservationNumber': { $exists: true, $eq: objectReservationNumberEq }
+                    });
+                }
+                const objectSubReservationIdIn = params.object?.reservations?.id?.$in;
+                if (Array.isArray(objectSubReservationIdIn)) {
+                    andConditions.push({
+                        'object.subReservation.id': {
+                            $exists: true,
+                            $in: objectSubReservationIdIn
+                        }
+                    });
+                }
+                if (params.object !== undefined) {
+                    if (params.object.reservations !== undefined) {
+                        // discontinue(2026-08-10~)
+                        // if (params.object.reservations.reservationNumber !== undefined) {
+                        //     if (Array.isArray(params.object.reservations.reservationNumber.$in)) {
+                        //         andConditions.push({
+                        //             'object.subReservation.reservationNumber': {
+                        //                 $exists: true,
+                        //                 $in: params.object.reservations.reservationNumber.$in
+                        //             }
+                        //         });
+                        //     }
+                        // }
+                        // discontinue(2026-08-10~)
+                        // if (params.object.reservations.reservationFor !== undefined) {
+                        //     if (params.object.reservations.reservationFor.id !== undefined) {
+                        //         if (Array.isArray(params.object.reservations.reservationFor.id.$in)) {
+                        //             andConditions.push({
+                        //                 'object.subReservation.reservationFor.id': {
+                        //                     $exists: true,
+                        //                     $in: params.object.reservations.reservationFor.id.$in
+                        //                 }
+                        //             });
+                        //         }
+                        //     }
+                        // }
+                    }
+                }
+                // discontinue(2026-08-10~)
+                // const objectUnderNameIdEq = params.object?.underName?.id?.$eq;
+                // if (typeof objectUnderNameIdEq === 'string') {
+                //     andConditions.push({
+                //         'object.underName.id': {
+                //             $exists: true,
+                //             $eq: objectUnderNameIdEq
+                //         }
+                //     });
+                // }
+                const objectSubReservationSeatNumberEq = params.object?.reservations?.reservedTicket?.ticketedSeat?.seatNumber?.$eq;
+                if (typeof objectSubReservationSeatNumberEq === 'string') {
+                    andConditions.push({
+                        'object.subReservation.reservedTicket.ticketedSeat.seatNumber': {
+                            $exists: true,
+                            $eq: objectSubReservationSeatNumberEq
+                        }
+                    });
+                }
+                break;
+            }
+            default:
+        }
+        return andConditions;
+    }
+    async countPotentiallyExportTasks(params) {
+        const { endDate, limit } = params;
+        const endDateLt = endDate?.$lt;
+        if (!(endDateLt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('endDate.$lt', 'must be Date');
+        }
+        const query = this.transactionModel.countDocuments({
+            status: {
+                $in: [
+                    factory_1.factory.transactionStatusType.Canceled,
+                    factory_1.factory.transactionStatusType.Confirmed,
+                    factory_1.factory.transactionStatusType.Expired
+                ]
+            },
+            'tasksExportAction.actionStatus': {
+                $exists: true,
+                $eq: factory_1.factory.actionStatusType.PotentialActionStatus
+            },
+            endDate: { $exists: true, $lt: endDateLt }
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * tasksExportAction.actionStatusがActiveActionStatusのまま一定時間経過した取引について
+     * PotentialActionStatusに変更する
+     * 2025-03-10~
+     */
+    async reExportAction(params) {
+        const { startDate } = params;
+        if (!(startDate.$lt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('startDate.$lt', 'must be Date');
+        }
+        return this.transactionModel.updateMany({
+            'tasksExportAction.actionStatus': {
+                $exists: true,
+                $eq: factory_1.factory.actionStatusType.ActiveActionStatus
+            },
+            'tasksExportAction.startDate': {
+                $exists: true,
+                $lt: startDate.$lt
+            }
+        }, {
+            $set: {
+                tasksExportAction: {
+                    actionStatus: factory_1.factory.actionStatusType.PotentialActionStatus
+                }
+            }
+        })
+            .exec();
+    }
+    // /**
+    //  * タスクエクスポートの遅延している取引について明示的にemitTransactionStatusChangedを実行する
+    //  */
+    // public async exportTasksMany(params: {
+    //     now: Date;
+    //     delayInSeconds: number;
+    //     status: {
+    //         $in: factory.transactionStatusType[];
+    //     };
+    //     limit: number;
+    // }) {
+    //     const delayedTransactions = await this.transactionModel.find({
+    //         status: { $in: params.status.$in },
+    //         'tasksExportAction.actionStatus': {
+    //             $exists: true,
+    //             $eq: factory.actionStatusType.PotentialActionStatus
+    //         },
+    //         endDate: {
+    //             $exists: true,
+    //             $lt: moment(params.now)
+    //                 .add(-params.delayInSeconds, 'seconds')
+    //                 .toDate()
+    //         }
+    //     })
+    //         .select({
+    //             _id: 0,
+    //             id: { $toString: '$_id' },
+    //             typeOf: 1,
+    //             status: 1
+    //         })
+    //         .limit(params.limit)
+    //         .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .lean<Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'id' | 'status' | 'typeOf'>[]>()
+    //         .exec();
+    //     if (delayedTransactions.length > 0) {
+    //         delayedTransactions.forEach((delayedTransaction) => {
+    //             assetTransactionEventEmitter.emitAssetTransactionStatusChanged({
+    //                 id: delayedTransaction.id,
+    //                 typeOf: delayedTransaction.typeOf,
+    //                 status: delayedTransaction.status
+    //             });
+    //         });
+    //     }
+    //     return delayedTransactions;
+    // }
+    /**
+     * add(2025-03-17~)
+     */
+    async countPotentiallyExpired(params) {
+        const { expires, limit } = params;
+        const query = this.transactionModel.countDocuments({
+            status: { $eq: factory_1.factory.transactionStatusType.InProgress },
+            expires: { $lt: expires.$lt }
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * add(2025-03-12~)
+     */
+    async makeOneExpiredIfExists(params) {
+        const endDate = new Date();
+        const sort = {
+            expires: factory_1.factory.sortType.Ascending
+        };
+        const doc = await this.transactionModel.findOneAndUpdate({
+            status: { $eq: factory_1.factory.transactionStatusType.InProgress },
+            expires: { $lt: params.expires.$lt }
+        }, {
+            status: factory_1.factory.transactionStatusType.Expired,
+            endDate
+        }, {
+            new: true,
+            projection: {
+                _id: 0,
+                id: { $toString: '$_id' },
+                typeOf: 1
+            }
+        })
+            .sort(sort)
+            .lean()
+            .exec();
+        if (doc === null) {
+            // no op
+            return;
+        }
+        else {
+            assetTransaction_2.assetTransactionEventEmitter.emitAssetTransactionStatusChanged({
+                id: doc.id,
+                typeOf: doc.typeOf,
+                status: factory_1.factory.transactionStatusType.Expired
+            });
+            return doc;
+        }
+    }
+    // /**
+    //  * 取引を期限切れにする
+    //  */
+    // public async makeExpired(params: {
+    //     expires: { $lt: Date };
+    // }): Promise<void> {
+    //     // IDをemitしたいのでまずリスト検索(2023-04-27~)
+    //     const expiringTransactions: Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'id' | 'typeOf'>[] =
+    //         await this.transactionModel.find({
+    //             status: { $eq: factory.transactionStatusType.InProgress },
+    //             expires: { $lt: params.expires.$lt }
+    //         })
+    //             .select({
+    //                 _id: 1,
+    //                 typeOf: 1
+    //             })
+    //             .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //             .exec();
+    //     if (expiringTransactions.length > 0) {
+    //         // ステータスと期限を見て更新
+    //         await this.transactionModel.updateMany(
+    //             {
+    //                 _id: { $in: expiringTransactions.map((t) => t.id) },
+    //                 status: { $eq: factory.transactionStatusType.InProgress },
+    //                 expires: { $lt: params.expires.$lt }
+    //             },
+    //             {
+    //                 status: factory.transactionStatusType.Expired,
+    //                 endDate: new Date()
+    //             }
+    //         )
+    //             .exec();
+    //         expiringTransactions.forEach((expiringTransaction) => {
+    //             assetTransactionEventEmitter.emitAssetTransactionStatusChanged({
+    //                 id: expiringTransaction.id,
+    //                 typeOf: expiringTransaction.typeOf,
+    //                 status: factory.transactionStatusType.Expired
+    //             });
+    //         });
+    //     }
+    // }
+    async countAssetTransactions(params) {
+        const { limit } = params;
+        const conditions = AdminAssetTransactionRepo.CREATE_MONGO_CONDITIONS(params);
+        const query = this.transactionModel.countDocuments((conditions.length > 0) ? { $and: conditions } : {});
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * 取引を検索する
+     */
+    async findAssetTransactions(params, inclusion, exclusion) {
+        const conditions = AdminAssetTransactionRepo.CREATE_MONGO_CONDITIONS(params);
+        let projection = {};
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            inclusion.forEach((field) => {
+                projection[field] = 1;
+            });
+        }
+        else {
+            projection = {
+                __v: 0,
+                createdAt: 0,
+                updatedAt: 0
+            };
+            if (Array.isArray(exclusion) && exclusion.length > 0) {
+                exclusion.forEach((field) => {
+                    projection[field] = 0;
+                });
+            }
+        }
+        const query = this.transactionModel.find((conditions.length > 0) ? { $and: conditions } : {})
+            .select(projection);
+        if (typeof params.limit === 'number' && params.limit > 0) {
+            const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
+            query.limit(params.limit)
+                .skip(params.limit * (page - 1));
+        }
+        /* istanbul ignore else */
+        if (params.sort?.startDate !== undefined) {
+            query.sort({ startDate: params.sort.startDate });
+        }
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec()
+            .then((docs) => docs.map((doc) => doc.toObject()));
+    }
+    /**
+     * 終了日時を一定期間過ぎたアクションを削除する
+     */
+    async deleteEndDatePassedCertainPeriod(params) {
+        return this.transactionModel.deleteMany({
+            // 終了日時を一定期間過ぎたもの
+            endDate: {
+                $exists: true,
+                $lt: params.$lt
+            }
+        })
+            .exec();
+    }
+    getCursor(conditions, projection) {
+        return this.transactionModel.find(conditions, projection)
+            // .sort({ startDate: factory.sortType.Ascending })
+            .sort({ startDate: factory_1.factory.sortType.Descending })
+            .cursor();
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.transactionModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+}
+exports.AdminAssetTransactionRepo = AdminAssetTransactionRepo;

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

@@ -0,0 +1,43 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+interface IAggregationByStatus {
+    transactionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+    reservationCount: number;
+    avgGraceTime: number;
+    maxGraceTime: number;
+    minGraceTime: number;
+}
+interface IStatus {
+    status: factory.transactionStatusType;
+    aggregation: IAggregationByStatus;
+}
+export interface IAggregateReserve {
+    statuses: IStatus[];
+}
+/**
+ * 資産取引集計リポジトリ
+ */
+export declare class AggregateAssetTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    aggregateAssetTransaction(params: {
+        project?: {
+            id?: {
+                $eq?: string;
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.assetTransactionType;
+    }): Promise<IAggregateReserve>;
+    private agggregateByStatus;
+}
+export {};