@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

package/lib/chevre/service/report/telemetry.js

@@ -0,0 +1,440 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStock = exports.createFlow = exports.search = exports.searchSellerStock = exports.searchSellerFlow = exports.searchGlobalStock = exports.searchGlobalFlow = exports.TelemetryPurposeType = exports.TelemetryScope = void 0;
+const createDebug = require("debug");
+const moment = require("moment");
+const factory = require("../../factory");
+const debug = createDebug('chevre-domain:service');
+const TELEMETRY_UNIT_OF_MEASUREMENT_IN_SECONDS = 60; // 測定単位時間(秒)
+var TelemetryScope;
+(function (TelemetryScope) {
+    TelemetryScope["Global"] = "Global";
+    TelemetryScope["Seller"] = "Seller";
+})(TelemetryScope = exports.TelemetryScope || (exports.TelemetryScope = {}));
+var TelemetryPurposeType;
+(function (TelemetryPurposeType) {
+    TelemetryPurposeType["Flow"] = "Flow";
+    TelemetryPurposeType["Stock"] = "Stock";
+})(TelemetryPurposeType = exports.TelemetryPurposeType || (exports.TelemetryPurposeType = {}));
+function searchGlobalFlow(searchConditions) {
+    return search(Object.assign(Object.assign({}, searchConditions), { scope: TelemetryScope.Global, purpose: TelemetryPurposeType.Flow }));
+}
+exports.searchGlobalFlow = searchGlobalFlow;
+function searchGlobalStock(searchConditions) {
+    return search(Object.assign(Object.assign({}, searchConditions), { scope: TelemetryScope.Global, purpose: TelemetryPurposeType.Stock }));
+}
+exports.searchGlobalStock = searchGlobalStock;
+function searchSellerFlow(searchConditions) {
+    return search(Object.assign(Object.assign({}, searchConditions), { scope: TelemetryScope.Seller, purpose: TelemetryPurposeType.Flow }));
+}
+exports.searchSellerFlow = searchSellerFlow;
+function searchSellerStock(searchConditions) {
+    return search(Object.assign(Object.assign({}, searchConditions), { scope: TelemetryScope.Seller, purpose: TelemetryPurposeType.Stock }));
+}
+exports.searchSellerStock = searchSellerStock;
+/**
+ * 計測データを検索する
+ * @param searchConditions.measuredFrom 計測日時from
+ * @param searchConditions.measuredThrough 計測日時through
+ */
+function search(searchConditions) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        return yield repos.telemetry.telemetryModel.find({
+            'object.scope': {
+                $exists: true,
+                $eq: searchConditions.scope
+            },
+            'object.measuredAt': {
+                $exists: true,
+                $gte: searchConditions.measuredFrom,
+                $lt: searchConditions.measuredThrough
+            },
+            'purpose.typeOf': {
+                $exists: true,
+                $eq: searchConditions.purpose
+            }
+        })
+            .sort({ 'object.measuredAt': 1 })
+            .lean()
+            .exec();
+    });
+}
+exports.search = search;
+/**
+ * フロー測定データを作成する
+ */
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function createFlow(target) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const startDate = new Date();
+        const measuredThrough = moment(target.measuredAt);
+        const measuredFrom = moment(measuredThrough)
+            .add(-TELEMETRY_UNIT_OF_MEASUREMENT_IN_SECONDS, 'seconds');
+        let telemetry;
+        if (target.sellerId !== undefined) {
+            const flowData = yield createSellerFlow(measuredFrom.toDate(), measuredThrough.toDate(), target.sellerId)({
+                transaction: repos.transaction,
+                action: repos.action
+            });
+            debug('flowData created.');
+            telemetry = {
+                purpose: { typeOf: TelemetryPurposeType.Flow },
+                object: {
+                    scope: TelemetryScope.Seller,
+                    measuredAt: target.measuredAt,
+                    sellerId: target.sellerId
+                },
+                result: flowData,
+                startDate: startDate,
+                endDate: new Date()
+            };
+        }
+        else {
+            const flowData = yield createGlobalFlow(measuredFrom.toDate(), measuredThrough.toDate())({
+                task: repos.task
+            });
+            debug('flowData created.');
+            telemetry = {
+                purpose: { typeOf: TelemetryPurposeType.Flow },
+                object: {
+                    scope: TelemetryScope.Global,
+                    measuredAt: target.measuredAt
+                },
+                result: flowData,
+                startDate: startDate,
+                endDate: new Date()
+            };
+        }
+        yield repos.telemetry.telemetryModel.create(telemetry);
+        debug('telemetry saved.');
+    });
+}
+exports.createFlow = createFlow;
+/**
+ * ストック測定データを作成する
+ */
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function createStock(target) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const startDate = new Date();
+        let telemetry;
+        if (target.sellerId !== undefined) {
+            const stockData = yield createSellerStock(target.measuredAt, target.sellerId)({
+                transaction: repos.transaction
+            });
+            debug('stockData created.');
+            telemetry = {
+                purpose: { typeOf: TelemetryPurposeType.Stock },
+                object: {
+                    scope: TelemetryScope.Seller,
+                    measuredAt: target.measuredAt,
+                    sellerId: target.sellerId
+                },
+                result: stockData,
+                startDate: startDate,
+                endDate: new Date()
+            };
+        }
+        else {
+            const stockData = yield createGlobalStock(target.measuredAt)({ task: repos.task });
+            debug('stockData created.');
+            telemetry = {
+                purpose: { typeOf: TelemetryPurposeType.Stock },
+                object: {
+                    scope: TelemetryScope.Global,
+                    measuredAt: target.measuredAt
+                },
+                result: stockData,
+                startDate: startDate,
+                endDate: new Date()
+            };
+        }
+        yield repos.telemetry.telemetryModel.create(telemetry);
+        debug('telemetry saved.');
+    });
+}
+exports.createStock = createStock;
+/**
+ * フロー計測データーを作成する
+ * @param measuredFrom 計測開始日時
+ * @param measuredThrough 計測終了日時
+ */
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function createSellerFlow(measuredFrom, measuredThrough, sellerId) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const { sellerFlowTransactionResult, expiredTransactionIds } = yield createSellerFlowTransactionResult(measuredFrom, measuredThrough, sellerId)(repos);
+        // 期限切れ取引数
+        const numberOfTransactionsExpired = sellerFlowTransactionResult.numberOfExpired;
+        // 期限切れ取引に対して作成されたアクションを取得
+        const actionsOnExpiredTransactions = yield repos.action.search({
+            typeOf: { $eq: factory.actionType.AuthorizeAction },
+            purpose: { id: { $in: expiredTransactionIds } }
+        });
+        debug(actionsOnExpiredTransactions.length, 'actionsOnExpiredTransactions found.');
+        const numbersOfActionsOnExpired = expiredTransactionIds.map((transactionId) => {
+            return actionsOnExpiredTransactions.filter((action) => action.purpose.id === transactionId).length;
+        });
+        const totalNumberOfActionsOnExpired = numbersOfActionsOnExpired.reduce((a, b) => a + b, 0);
+        const maxNumberOfActionsOnExpired = numbersOfActionsOnExpired.reduce((a, b) => Math.max(a, b), 0);
+        const minNumberOfActionsOnExpired = numbersOfActionsOnExpired.reduce((a, b) => Math.min(a, b), (numberOfTransactionsExpired > 0) ? numbersOfActionsOnExpired[0] : 0);
+        const averageNumberOfActionsOnExpired = (numberOfTransactionsExpired > 0) ? totalNumberOfActionsOnExpired / numberOfTransactionsExpired : 0;
+        return {
+            transactions: Object.assign(Object.assign({}, sellerFlowTransactionResult), { totalNumberOfActionsOnExpired: totalNumberOfActionsOnExpired, maxNumberOfActionsOnExpired: maxNumberOfActionsOnExpired, minNumberOfActionsOnExpired: minNumberOfActionsOnExpired, averageNumberOfActionsOnExpired: parseFloat(averageNumberOfActionsOnExpired.toFixed(1)), 
+                // tslint:disable-next-line:no-suspicious-comment
+                totalNumberOfOrderItems: 0, 
+                // tslint:disable-next-line:no-suspicious-comment
+                maxNumberOfOrderItems: 0, 
+                // tslint:disable-next-line:no-suspicious-comment
+                minNumberOfOrderItems: 0, 
+                // tslint:disable-next-line:no-suspicious-comment
+                averageNumberOfOrderItems: 0 // TODO 実装
+             }),
+            measuredFrom: measuredFrom,
+            measuredThrough: measuredThrough
+        };
+    });
+}
+function createSellerFlowTransactionResult(measuredFrom, measuredThrough, sellerId) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 計測期間内に開始された取引数を算出する
+        const numberOfTransactionsStarted = yield repos.transaction.count({
+            typeOf: factory.transactionType.PlaceOrder,
+            seller: { ids: [sellerId] },
+            startFrom: measuredFrom,
+            startThrough: measuredThrough
+        });
+        // 計測期間内に開始され、かつ、すでに終了している取引を検索
+        const startedAndEndedTransactions = yield repos.transaction.search({
+            typeOf: factory.transactionType.PlaceOrder,
+            seller: { ids: [sellerId] },
+            startFrom: measuredFrom,
+            startThrough: measuredThrough,
+            endThrough: new Date()
+        });
+        const numberOfStartedAndConfirmed = startedAndEndedTransactions.filter((transaction) => transaction.status === factory.transactionStatusType.Confirmed).length;
+        const numberOfStartedAndExpired = startedAndEndedTransactions.filter((transaction) => transaction.status === factory.transactionStatusType.Expired).length;
+        const endedTransactions = yield repos.transaction.search({
+            typeOf: factory.transactionType.PlaceOrder,
+            seller: { ids: [sellerId] },
+            endFrom: measuredFrom,
+            endThrough: measuredThrough
+        });
+        debug(endedTransactions.length, 'endedTransactions found.');
+        const confirmedTransactions = endedTransactions.filter((transaction) => transaction.status === factory.transactionStatusType.Confirmed);
+        const expiredTransactions = endedTransactions.filter((transaction) => transaction.status === factory.transactionStatusType.Expired);
+        const numberOfTransactionsConfirmed = confirmedTransactions.length;
+        // 所要時間算出(期間の成立取引リストを取得し、開始時刻と成立時刻の差を所要時間とする)
+        const requiredTimesConfirmed = confirmedTransactions.map((transaction) => moment(transaction.endDate)
+            .diff(moment(transaction.startDate, 'milliseconds')));
+        const totalRequiredTimeInMilliseconds = requiredTimesConfirmed.reduce((a, b) => a + b, 0);
+        const maxRequiredTimeInMilliseconds = requiredTimesConfirmed.reduce((a, b) => Math.max(a, b), 0);
+        const minRequiredTimeInMilliseconds = requiredTimesConfirmed.reduce((a, b) => Math.min(a, b), (numberOfTransactionsConfirmed > 0) ? requiredTimesConfirmed[0] : 0);
+        const averageRequiredTimeInMilliseconds = (numberOfTransactionsConfirmed > 0) ? totalRequiredTimeInMilliseconds / numberOfTransactionsConfirmed : 0;
+        // イベントまでの残り時間算出(イベント開始日時と成立日時の差)
+        const timesLeftUntilEvent = confirmedTransactions.map((transaction) => {
+            // 座席予約は必ず存在する
+            const seatReservation = transaction.object.authorizeActions.find((action) => action.object.typeOf === factory.action.authorize.offer.seatReservation.ObjectType.SeatReservation);
+            return moment(seatReservation.object.event.startDate)
+                .diff(moment(transaction.endDate), 'milliseconds');
+        });
+        const totalTimeLeftUntilEventInMilliseconds = timesLeftUntilEvent.reduce((a, b) => a + b, 0);
+        const maxTimeLeftUntilEventInMilliseconds = timesLeftUntilEvent.reduce((a, b) => Math.max(a, b), 0);
+        const minTimeLeftUntilEventInMilliseconds = timesLeftUntilEvent.reduce((a, b) => Math.min(a, b), (numberOfTransactionsConfirmed > 0) ? timesLeftUntilEvent[0] : 0);
+        const averageTimeLeftUntilEventInMilliseconds = (numberOfTransactionsConfirmed > 0) ? totalTimeLeftUntilEventInMilliseconds / numberOfTransactionsConfirmed : 0;
+        // 金額算出
+        const amounts = confirmedTransactions.map((transaction) => transaction.result.order.price);
+        const totalAmount = amounts.reduce((a, b) => a + b, 0);
+        const maxAmount = amounts.reduce((a, b) => Math.max(a, b), 0);
+        const minAmount = amounts.reduce((a, b) => Math.min(a, b), (numberOfTransactionsConfirmed > 0) ? amounts[0] : 0);
+        const averageAmount = (numberOfTransactionsConfirmed > 0) ? totalAmount / numberOfTransactionsConfirmed : 0;
+        // アクション数集計
+        const numbersOfActions = confirmedTransactions.map((t) => t.object.authorizeActions.length);
+        const totalNumberOfActions = numbersOfActions.reduce((a, b) => a + b, 0);
+        const maxNumberOfActions = numbersOfActions.reduce((a, b) => Math.max(a, b), 0);
+        const minNumberOfActions = numbersOfActions.reduce((a, b) => Math.min(a, b), (numberOfTransactionsConfirmed > 0) ? numbersOfActions[0] : 0);
+        const averageNumberOfActions = (numberOfTransactionsConfirmed > 0) ? totalNumberOfActions / numberOfTransactionsConfirmed : 0;
+        // 期限切れ取引数
+        const numberOfTransactionsExpired = expiredTransactions.length;
+        const expiredTransactionIds = expiredTransactions.map((transaction) => transaction.id);
+        return {
+            sellerFlowTransactionResult: {
+                numberOfStarted: numberOfTransactionsStarted,
+                numberOfStartedAndConfirmed: numberOfStartedAndConfirmed,
+                numberOfStartedAndExpired: numberOfStartedAndExpired,
+                numberOfConfirmed: numberOfTransactionsConfirmed,
+                numberOfExpired: numberOfTransactionsExpired,
+                totalRequiredTimeInMilliseconds: totalRequiredTimeInMilliseconds,
+                maxRequiredTimeInMilliseconds: maxRequiredTimeInMilliseconds,
+                minRequiredTimeInMilliseconds: minRequiredTimeInMilliseconds,
+                averageRequiredTimeInMilliseconds: parseFloat(averageRequiredTimeInMilliseconds.toFixed(1)),
+                totalTimeLeftUntilEventInMilliseconds: totalTimeLeftUntilEventInMilliseconds,
+                maxTimeLeftUntilEventInMilliseconds: maxTimeLeftUntilEventInMilliseconds,
+                minTimeLeftUntilEventInMilliseconds: minTimeLeftUntilEventInMilliseconds,
+                averageTimeLeftUntilEventInMilliseconds: averageTimeLeftUntilEventInMilliseconds,
+                totalAmount: totalAmount,
+                maxAmount: maxAmount,
+                minAmount: minAmount,
+                averageAmount: parseFloat(averageAmount.toFixed(1)),
+                totalNumberOfActionsOnConfirmed: totalNumberOfActions,
+                maxNumberOfActionsOnConfirmed: maxNumberOfActions,
+                minNumberOfActionsOnConfirmed: minNumberOfActions,
+                averageNumberOfActionsOnConfirmed: parseFloat(averageNumberOfActions.toFixed(1)),
+                // tslint:disable-next-line:no-suspicious-comment
+                totalNumberOfOrderItems: 0,
+                // tslint:disable-next-line:no-suspicious-comment
+                maxNumberOfOrderItems: 0,
+                // tslint:disable-next-line:no-suspicious-comment
+                minNumberOfOrderItems: 0,
+                // tslint:disable-next-line:no-suspicious-comment
+                averageNumberOfOrderItems: 0 // TODO 実装
+            },
+            expiredTransactionIds
+        };
+    });
+}
+/**
+ * ストック計測データを作成する
+ * @param measuredAt 計測日時
+ */
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function createSellerStock(measuredAt, sellerId) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // {measuredAt}以前に開始し、{measuredAt}以後に成立あるいは期限切れした取引
+        const numTransactionsUnderway1 = yield repos.transaction.count({
+            typeOf: factory.transactionType.PlaceOrder,
+            seller: { ids: [sellerId] },
+            startThrough: measuredAt,
+            endFrom: measuredAt
+        });
+        // {measuredAt}以前に開始し、いまだに進行中の取引
+        const numTransactionsUnderway2 = yield repos.transaction.count({
+            typeOf: factory.transactionType.PlaceOrder,
+            seller: { ids: [sellerId] },
+            startThrough: measuredAt,
+            statuses: [factory.transactionStatusType.InProgress]
+        });
+        const numberOfTransactionsUnderway = numTransactionsUnderway1 + numTransactionsUnderway2;
+        debug('numberOfTransactionsUnderway:', numberOfTransactionsUnderway);
+        return {
+            transactions: {
+                numberOfUnderway: numberOfTransactionsUnderway
+            },
+            measuredAt: measuredAt
+        };
+    });
+}
+/**
+ * フロー計測データーを作成する
+ * @param measuredFrom 計測開始日時
+ * @param measuredThrough 計測終了日時
+ */
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function createGlobalFlow(measuredFrom, measuredThrough) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 全タスク名リスト
+        const targetTaskNames = Object.keys(factory.taskName)
+            .map((k) => factory.taskName[k]);
+        const taskResults = yield Promise.all(targetTaskNames.map((taskName) => __awaiter(this, void 0, void 0, function* () {
+            const numberOfTasksCreated = yield repos.task.taskModel.count({
+                name: taskName,
+                createdAt: {
+                    $gte: measuredFrom,
+                    $lt: measuredThrough
+                }
+            })
+                .exec();
+            debug('numberOfTasksCreated:', numberOfTasksCreated);
+            // 実行中止ステータスで、最終試行日時が範囲にあるものを実行タスク数とする
+            const numberOfTasksAborted = yield repos.task.taskModel.count({
+                name: taskName,
+                lastTriedAt: {
+                    $type: 'date',
+                    $gte: measuredFrom,
+                    $lt: measuredThrough
+                },
+                status: factory.taskStatus.Aborted
+            })
+                .exec();
+            debug('numberOfTasksAborted:', numberOfTasksAborted);
+            // 実行済みステータスで、最終試行日時が範囲にあるものを実行タスク数とする
+            const executedTasks = yield repos.task.taskModel.find({
+                name: taskName,
+                lastTriedAt: {
+                    $type: 'date',
+                    $gte: measuredFrom,
+                    $lt: measuredThrough
+                },
+                status: factory.taskStatus.Executed
+            }, 'runsAt lastTriedAt numberOfTried')
+                .exec()
+                .then((docs) => docs.map((doc) => doc.toObject()));
+            debug(executedTasks.length, 'executedTasks found.');
+            const numberOfTasksExecuted = executedTasks.length;
+            const latencies = executedTasks.map((task) => moment(task.lastTriedAt)
+                .diff(moment(task.runsAt, 'milliseconds')));
+            const totalLatency = latencies.reduce((a, b) => a + b, 0);
+            const maxLatency = latencies.reduce((a, b) => Math.max(a, b), 0);
+            const minLatency = latencies.reduce((a, b) => Math.min(a, b), (numberOfTasksExecuted > 0) ? latencies[0] : 0);
+            const numbersOfTrials = yield Promise.all(executedTasks.map((task) => task.numberOfTried));
+            const totalNumberOfTrials = numbersOfTrials.reduce((a, b) => a + b, 0);
+            const maxNumberOfTrials = numbersOfTrials.reduce((a, b) => Math.max(a, b), 0);
+            const minNumberOfTrials = numbersOfTrials.reduce((a, b) => Math.min(a, b), (numberOfTasksExecuted > 0) ? numbersOfTrials[0] : 0);
+            return {
+                name: taskName,
+                numberOfCreated: numberOfTasksCreated,
+                numberOfExecuted: numberOfTasksExecuted,
+                numberOfAborted: numberOfTasksAborted,
+                totalLatencyInMilliseconds: totalLatency,
+                maxLatencyInMilliseconds: maxLatency,
+                minLatencyInMilliseconds: minLatency,
+                totalNumberOfTrials: totalNumberOfTrials,
+                maxNumberOfTrials: maxNumberOfTrials,
+                minNumberOfTrials: minNumberOfTrials
+            };
+        })));
+        return {
+            tasks: taskResults,
+            measuredFrom: measuredFrom,
+            measuredThrough: measuredThrough
+        };
+    });
+}
+/**
+ * ストック計測データを作成する
+ * @param measuredAt 計測日時
+ */
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function createGlobalStock(measuredAt) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 待機状態のタスク数を算出
+        debug('counting waiting tasks globally...');
+        const numberOfTasksUnexecuted = yield repos.task.taskModel.count({
+            runsAt: { $lt: measuredAt },
+            status: { $in: [factory.taskStatus.Ready, factory.taskStatus.Running] }
+        })
+            .exec();
+        debug('global waiting tasks count', numberOfTasksUnexecuted);
+        return {
+            tasks: {
+                numberOfUnexecuted: numberOfTasksUnexecuted
+            },
+            measuredAt: measuredAt
+        };
+    });
+}

package/lib/chevre/service/report.d.ts

@@ -0,0 +1,6 @@
+/**
+ * レポートサービス
+ */
+import * as OwnershipInfoService from './report/ownershipInfo';
+import * as TelemetryService from './report/telemetry';
+export { OwnershipInfoService as ownershipInfo, TelemetryService as telemetry };

package/lib/chevre/service/report.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetry = exports.ownershipInfo = void 0;
+/**
+ * レポートサービス
+ */
+const OwnershipInfoService = require("./report/ownershipInfo");
+exports.ownershipInfo = OwnershipInfoService;
+const TelemetryService = require("./report/telemetry");
+exports.telemetry = TelemetryService;

package/lib/chevre/service/reserve/cancelReservation.d.ts

@@ -0,0 +1,37 @@
+import * as factory from '../../factory';
+import { MongoRepository as ActionRepo } from '../../repo/action';
+import { MongoRepository as AssetTransactionRepo } from '../../repo/assetTransaction';
+import { RedisRepository as ScreeningEventAvailabilityRepo } from '../../repo/itemAvailability/screeningEvent';
+import { RedisRepository as OfferRateLimitRepo } from '../../repo/rateLimit/offer';
+import { MongoRepository as ReservationRepo } from '../../repo/reservation';
+import { MongoRepository as TaskRepo } from '../../repo/task';
+declare type IObjectSubReservation = factory.assetTransaction.reserve.IObjectSubReservation;
+/**
+ * 進行中の予約をキャンセルする
+ */
+export declare function cancelPendingReservation(actionAttributesList: factory.action.cancel.reservation.IAttributes[]): (repos: {
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    eventAvailability: ScreeningEventAvailabilityRepo;
+    offerRateLimit: OfferRateLimitRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+}) => Promise<void>;
+/**
+ * 予約をキャンセルする
+ */
+export declare function cancelReservation(actionAttributesList: factory.action.cancel.reservation.IAttributes[]): (repos: {
+    action: ActionRepo;
+    eventAvailability: ScreeningEventAvailabilityRepo;
+    offerRateLimit: OfferRateLimitRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<void>;
+export declare function processUnlockOfferRateLimit(params: {
+    reservation: IObjectSubReservation;
+    reservationFor: factory.assetTransaction.reserve.IReservationFor;
+}): (repos: {
+    offerRateLimit: OfferRateLimitRepo;
+}) => Promise<void>;
+export {};