@chevre/domain 24.0.0-alpha.2 → 24.0.0-alpha.21

package/lib/chevre/repo/orderNumber.js

@@ -34,11 +34,6 @@ const setting_1 = require("./mongoose/schemas/setting");
 const transactionNumber_2 = require("./mongoose/schemas/transactionNumber");
 const transactionNumberCounter_1 = require("./transactionNumberCounter");
 const ORDER_NUMBER_SEPARATOR = '-';
-const defaultVersioningForceProjects = [
-    'HMX',
-    'SMT',
-    'KOJ'
-];
 /**
  * 注文番号リポジトリ
  */
@@ -59,16 +54,23 @@ class OrderNumberRepo {
     //     return orderNumber;
     // }
     /**
-     * タイムスタンプから発行する
+     * 注文日時から新しい注文番号を発行する
+     * グローバルユニークである前提
      */
-    async publishByTimestamp(params) {
-        const { fpeSecret, version, validFrom, versioningForceProjects, versioningExceptionProjects } = await this.findSetting();
+    async issueOrderNumber(params) {
+        const { fpeSecret, version, validFrom
+        // versioningForceProjects
+        // versioningExceptionProjects
+         } = await this.findSetting();
         const timestamp = (0, moment_timezone_1.default)(params.orderDate)
             .valueOf()
             .toString();
+        // const projectPrefix = params.project.alternateName
+        //     .toUpperCase();
         const projectPrefix = params.project.alternateName
-            .toUpperCase();
-        const dataFeedIdentifier = `${projectPrefix}:${timestamp}`;
+            .toUpperCase().at(0);
+        // const dataFeedIdentifier = `${projectPrefix}:${timestamp}`;
+        const dataFeedIdentifier = timestamp; // reconsider increment scope(2026-02-21~)
         const dataFeedExpires = (0, moment_timezone_1.default)(params.orderDate)
             .add(1, 'minute') // ミリ秒でカウントしていくので、注文日時後1分で十分
             .toDate();
@@ -78,18 +80,12 @@ class OrderNumberRepo {
             expires: dataFeedExpires
         });
         let orderNumber;
-        let useVersioning = (validFrom instanceof Date && (0, moment_timezone_1.default)(validFrom)
-            .isSameOrBefore(params.orderDate))
-            // versioningForceProjectsであれば強制的にversioning(2026-02-05~)
-            || versioningForceProjects.includes(projectPrefix);
-        // versioningExceptionProjectsであれば強制的にversioning不使用(2026-02-10~)
-        if (versioningExceptionProjects.includes(projectPrefix)) {
-            useVersioning = false;
-        }
+        const useVersioning = (validFrom instanceof Date && (0, moment_timezone_1.default)(validFrom)
+            .isSameOrBefore(params.orderDate));
         if (typeof fpeSecret === 'string' && typeof version === 'string' && useVersioning) {
             const transactionFactory = new transactionNumber_1.TransactionNumberFactory({ fpeSecret, version });
             orderNumber = transactionFactory.generate(timestamp, incrReply);
-            orderNumber = `${projectPrefix.at(0)}${orderNumber}`; // 桁数をversion0に合わせるためにエイリアスの1文字目のみを採用
+            orderNumber = `${projectPrefix}${orderNumber}`; // 桁数をversion0に合わせるためにエイリアスの1文字目のみを採用
             orderNumber = `${[
                 orderNumber.slice(0, 4),
                 orderNumber.slice(4, 11),
@@ -138,11 +134,11 @@ class OrderNumberRepo {
             .exec();
         if (setting === null || setting.orderNumber === undefined) {
             return {
-                versioningForceProjects: [],
-                versioningExceptionProjects: []
+            // versioningForceProjects: []
+            // versioningExceptionProjects: []
             };
         }
-        const { fpeSecret, version, validFrom, versioningForceProjects, versioningExceptionProjects } = setting.orderNumber;
+        const { fpeSecret, version, validFrom } = setting.orderNumber;
         if (typeof fpeSecret !== 'string' || fpeSecret === '') {
             throw new factory.errors.NotFound('setting.orderNumber.secret');
         }
@@ -153,12 +149,11 @@ class OrderNumberRepo {
             throw new factory.errors.NotFound('setting.orderNumber.validFrom must be Date');
         }
         return {
-            fpeSecret, version, validFrom,
-            versioningForceProjects: [
-                ...(Array.isArray(versioningForceProjects)) ? versioningForceProjects : [],
-                ...defaultVersioningForceProjects
-            ],
-            versioningExceptionProjects: (Array.isArray(versioningExceptionProjects)) ? versioningExceptionProjects : []
+            fpeSecret, version, validFrom
+            // versioningForceProjects: [
+            //     ...(Array.isArray(versioningForceProjects)) ? versioningForceProjects : []
+            // ]
+            // versioningExceptionProjects: (Array.isArray(versioningExceptionProjects)) ? versioningExceptionProjects : []
         };
     }
 }

package/lib/chevre/repo/transaction/moneyTransfer.d.ts

@@ -0,0 +1,61 @@
+import type { Connection, FilterQuery } from 'mongoose';
+import * as factory from '../../factory';
+type IKeyOfProjection = keyof Pick<factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>, 'agent' | 'endDate' | 'expires' | 'project' | 'startDate' | 'status' | 'typeOf'> | Exclude<keyof factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>, 'id'>;
+type IOmittedFieldsInProgress = 'tasksExportAction' | 'tasksExportedAt' | 'tasksExportationStatus';
+export type IMoneyTransferTransactionInProgress = Omit<factory.transaction.moneyTransfer.ITransaction, IOmittedFieldsInProgress>;
+type IStartedTransactionFields = 'expires' | 'id' | 'startDate' | 'status';
+export type IStartedTransaction = Pick<factory.transaction.ITransaction<factory.transactionType>, IStartedTransactionFields>;
+/**
+ * 通貨転送取引リポジトリ
+ */
+export declare class MoneyTransferRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    static CREATE_MONGO_CONDITIONS(params: factory.transaction.ISearchConditions<factory.transactionType.MoneyTransfer>): FilterQuery<import("@chevre/factory/lib/assetTransaction/cancelReservation").ITransaction | import("@chevre/factory/lib/assetTransaction/moneyTransfer").ITransaction | import("@chevre/factory/lib/assetTransaction/pay").ITransaction | import("@chevre/factory/lib/assetTransaction/refund").ITransaction | import("@chevre/factory/lib/assetTransaction/registerService").ITransaction | import("@chevre/factory/lib/assetTransaction/reserve").ITransaction>[];
+    /**
+     * 取引を開始する
+     */
+    startMoneyTransfer(params: factory.transaction.IStartParams<factory.transactionType.MoneyTransfer>): Promise<IStartedTransaction>;
+    /**
+     * 特定取引検索
+     */
+    findMoneyTransferById(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
+        id: string;
+    }, inclusion: IKeyOfProjection[]): Promise<factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>>;
+    /**
+     * 進行中の取引を取得する
+     */
+    findMoneyTransferInProgressById(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
+        id: string;
+    }, inclusion: IKeyOfProjection[]): Promise<IMoneyTransferTransactionInProgress>;
+    /**
+     * 取引を確定する
+     */
+    confirmMoneyTransfer(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
+        id: string;
+        result: factory.transaction.IResult<factory.transactionType.MoneyTransfer>;
+        potentialActions: factory.transaction.IPotentialActions<factory.transactionType.MoneyTransfer>;
+    }): Promise<void>;
+    /**
+     * 取引を中止する
+     */
+    cancelMoneyTransfer(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
+        id: string;
+    }): Promise<void>;
+    countMoneyTransfer(params: factory.transaction.ISearchConditions<factory.transactionType.MoneyTransfer>): Promise<{
+        count: number;
+    }>;
+    /**
+     * 取引を検索する
+     */
+    findMoneyTransferTransactions(params: factory.transaction.ISearchConditions<factory.transactionType.MoneyTransfer> & {
+        inclusion: IKeyOfProjection[];
+    }): Promise<(Pick<factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>, IKeyOfProjection> & {
+        id: string;
+    })[]>;
+}
+export {};

package/lib/chevre/repo/transaction/moneyTransfer.js

@@ -0,0 +1,379 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoneyTransferRepo = void 0;
+const moment_1 = __importDefault(require("moment"));
+const transaction_1 = require("../../eventEmitter/transaction");
+const factory = __importStar(require("../../factory"));
+const settings_1 = require("../../settings");
+const transaction_2 = require("../mongoose/schemas/transaction");
+const AVAILABLE_PROJECT_FIELDS = [
+    'project',
+    'status',
+    'typeOf',
+    'agent',
+    'recipient',
+    'seller',
+    'error',
+    'result',
+    'object',
+    'expires',
+    'startDate',
+    'endDate',
+    'tasksExportAction',
+    'potentialActions',
+    // 'instrument'
+];
+/**
+ * 通貨転送取引リポジトリ
+ */
+class MoneyTransferRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(transaction_2.modelName, (0, transaction_2.createSchema)());
+    }
+    static CREATE_MONGO_CONDITIONS(params) {
+        if (params.typeOf !== factory.transactionType.MoneyTransfer) {
+            throw new factory.errors.Argument('typeOf', `must be ${factory.transactionType.MoneyTransfer}`);
+        }
+        const andConditions = [];
+        const projectIdEq = params.project?.id?.$eq;
+        if (typeof projectIdEq === 'string') {
+            andConditions.push({ 'project.id': { $eq: projectIdEq } });
+        }
+        if (typeof params.typeOf === 'string') {
+            andConditions.push({ typeOf: { $eq: params.typeOf } });
+        }
+        if (params.startFrom !== undefined) {
+            andConditions.push({
+                startDate: { $gte: params.startFrom }
+            });
+        }
+        if (params.startThrough !== undefined) {
+            andConditions.push({
+                startDate: { $lte: params.startThrough }
+            });
+        }
+        if (params.endFrom !== undefined) {
+            andConditions.push({
+                endDate: {
+                    $exists: true,
+                    $gte: params.endFrom
+                }
+            });
+        }
+        if (params.endThrough !== undefined) {
+            andConditions.push({
+                endDate: {
+                    $exists: true,
+                    $lt: params.endThrough
+                }
+            });
+        }
+        if (Array.isArray(params.ids)) {
+            andConditions.push({
+                _id: { $in: params.ids }
+            });
+        }
+        if (Array.isArray(params.statuses)) {
+            andConditions.push({ status: { $in: params.statuses } });
+        }
+        const statusIn = params.status?.$in;
+        if (Array.isArray(statusIn)) {
+            andConditions.push({ status: { $in: statusIn } });
+        }
+        if (params.agent !== undefined) {
+            if (params.agent.typeOf !== undefined) {
+                andConditions.push({
+                    'agent.typeOf': {
+                        $exists: true,
+                        $eq: params.agent.typeOf
+                    }
+                });
+            }
+            if (Array.isArray(params.agent.ids)) {
+                andConditions.push({
+                    'agent.id': {
+                        $exists: true,
+                        $in: params.agent.ids
+                    }
+                });
+            }
+            if (Array.isArray(params.agent.identifiers)) {
+                andConditions.push({
+                    'agent.identifier': {
+                        $exists: true,
+                        $in: params.agent.identifiers
+                    }
+                });
+            }
+        }
+        const tasksExportActionStatusIn = params.tasksExportAction?.actionStatus?.$in;
+        if (Array.isArray(tasksExportActionStatusIn)) {
+            andConditions.push({ 'tasksExportAction.actionStatus': { $exists: true, $in: tasksExportActionStatusIn } });
+        }
+        const tasksExportActionStatusEq = params.tasksExportAction?.actionStatus?.$eq;
+        if (typeof tasksExportActionStatusEq === 'string') {
+            andConditions.push({ 'tasksExportAction.actionStatus': { $exists: true, $eq: tasksExportActionStatusEq } });
+        }
+        switch (params.typeOf) {
+            case factory.transactionType.PlaceOrder:
+                throw new factory.errors.NotImplemented(`use PlaceOrderRepo`);
+            case factory.transactionType.ReturnOrder:
+                throw new factory.errors.NotImplemented(`use ReturnOrderRepo`);
+            default:
+        }
+        return andConditions;
+    }
+    /**
+     * 取引を開始する
+     */
+    // public async startNoPlaceOrder<
+    async startMoneyTransfer(params) {
+        const status = factory.transactionStatusType.InProgress;
+        const tasksExportAction = { actionStatus: factory.actionStatusType.PotentialActionStatus };
+        // const tasksExportationStatus = factory.transactionTasksExportationStatus.Unexported; // discontinue(2024-06-20~)
+        const startDate = new Date();
+        // let expires: Date;
+        const { typeOf } = params;
+        const expires = params.expires;
+        let creatingTransaction;
+        if (typeOf === factory.transactionType.MoneyTransfer) {
+            const { agent, project, object, seller, recipient } = params;
+            creatingTransaction = {
+                status, startDate, expires, typeOf, tasksExportAction,
+                agent, project, seller, object, recipient
+            };
+        }
+        else {
+            throw new factory.errors.NotImplemented(`${typeOf} not implemented`);
+        }
+        // reimplemnt with insertMany(2024-05-30~)
+        const result = await this.transactionModel.insertMany(creatingTransaction, { rawResult: true });
+        const id = result.insertedIds?.[0]?.toHexString();
+        if (typeof id !== 'string') {
+            throw new factory.errors.Internal('transaction not saved');
+        }
+        // 取引開始時にも取引イベントエミッター連携(2024-03-21~)
+        transaction_1.transactionEventEmitter.emitTransactionStatusChanged({ id, typeOf, status });
+        return { expires, id, startDate, status }; // minimize response(2024-05-30~)
+    }
+    /**
+     * 特定取引検索
+     */
+    async findMoneyTransferById(params, inclusion // make required(2024-05-31~)
+    ) {
+        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = positiveProjectionFields.filter((key) => inclusion.includes(key));
+        }
+        else {
+            throw new factory.errors.NotImplemented('inclusion must be specified'); // 2024-08-26~
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const doc = await this.transactionModel.findOne({
+            _id: { $eq: params.id },
+            typeOf: { $eq: params.typeOf }
+        }, projection)
+            .lean() // 2024-08-26~
+            .exec();
+        if (doc === null) {
+            throw new factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} not found`);
+        }
+        return doc;
+    }
+    /**
+     * 進行中の取引を取得する
+     */
+    async findMoneyTransferInProgressById(params, inclusion // make required(2024-05-29~)
+    ) {
+        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = positiveProjectionFields.filter((key) => inclusion.includes(key));
+        }
+        else {
+            throw new factory.errors.NotImplemented('inclusion must be specified'); // 2024-08-26~
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const filter = {
+            _id: { $eq: params.id },
+            typeOf: { $eq: params.typeOf },
+            status: { $eq: factory.transactionStatusType.InProgress },
+            // expiresを条件に追加(2023-05-12~),
+            expires: { $gt: new Date() }
+        };
+        const doc = await this.transactionModel.findOne(filter, projection)
+            .lean() // 2024-08-26~
+            .exec();
+        if (doc === null) {
+            throw new factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} ${factory.transactionStatusType.InProgress} not found`);
+        }
+        return doc;
+    }
+    /**
+     * 取引を確定する
+     */
+    // public async confirmNoPlaceOrder<
+    async confirmMoneyTransfer(params) {
+        const endDate = new Date();
+        const doc = await this.transactionModel.findOneAndUpdate({
+            _id: { $eq: params.id },
+            typeOf: { $eq: params.typeOf },
+            status: { $eq: factory.transactionStatusType.InProgress },
+            expires: { $gt: endDate } // add expires(2025-02-27~)
+        }, {
+            status: factory.transactionStatusType.Confirmed, // ステータス変更
+            endDate,
+            // 'object.authorizeActions': params.authorizeActions,
+            result: params.result, // resultを更新
+            potentialActions: params.potentialActions // resultを更新
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .lean()
+            .exec();
+        // NotFoundであれば取引状態確認
+        if (doc === null) {
+            const { expires, status } = await this.findMoneyTransferById({ typeOf: params.typeOf, id: params.id }, ['expires', 'status']);
+            if (status === factory.transactionStatusType.Confirmed) {
+                // すでに確定済の場合スルー
+            }
+            else if (status === factory.transactionStatusType.Expired) {
+                throw new factory.errors.Argument('Transaction id', 'Already expired');
+            }
+            else if (status === factory.transactionStatusType.Canceled) {
+                throw new factory.errors.Argument('Transaction id', 'Already canceled');
+            }
+            else {
+                if ((0, moment_1.default)(expires)
+                    .isSameOrBefore((0, moment_1.default)(endDate))) {
+                    throw new factory.errors.Argument('Transaction id', 'potentially expired');
+                }
+                throw new factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} ${factory.transactionStatusType.InProgress} not found`);
+            }
+        }
+        transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
+            id: params.id,
+            typeOf: params.typeOf,
+            status: factory.transactionStatusType.Confirmed
+        });
+    }
+    /**
+     * 取引を中止する
+     */
+    async cancelMoneyTransfer(params) {
+        const endDate = new Date();
+        // 進行中ステータスの取引を中止する
+        const doc = await this.transactionModel.findOneAndUpdate({
+            typeOf: params.typeOf,
+            _id: params.id,
+            status: factory.transactionStatusType.InProgress
+        }, {
+            status: factory.transactionStatusType.Canceled,
+            endDate: endDate
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .lean()
+            .exec();
+        // NotFoundであれば取引状態確認
+        if (doc === null) {
+            const { status } = await this.findMoneyTransferById(params, ['status']);
+            if (status === factory.transactionStatusType.Canceled) {
+                // すでに中止済の場合スルー
+            }
+            else if (status === factory.transactionStatusType.Expired) {
+                throw new factory.errors.Argument('Transaction id', 'Transaction already expired');
+            }
+            else if (status === factory.transactionStatusType.Confirmed) {
+                throw new factory.errors.Argument('Transaction id', 'Confirmed transaction unable to cancel');
+            }
+            else {
+                throw new factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} ${factory.transactionStatusType.InProgress} not found`);
+            }
+        }
+        transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
+            id: params.id,
+            typeOf: params.typeOf,
+            status: factory.transactionStatusType.Canceled
+        });
+    }
+    async countMoneyTransfer(params) {
+        const { limit } = params;
+        const conditions = MoneyTransferRepo.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 findMoneyTransferTransactions(params) {
+        const { inclusion } = params;
+        const conditions = MoneyTransferRepo.CREATE_MONGO_CONDITIONS(params);
+        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = positiveProjectionFields.filter((key) => inclusion.includes(key));
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        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));
+        }
+        if (params.sort?.startDate !== undefined) {
+            query.sort({ startDate: params.sort.startDate });
+        }
+        // const explainResult = await (<any>query).explain();
+        // console.log(explainResult[0].executionStats.allPlansExecution.map((e: any) => e.executionStages.inputStage));
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+    }
+}
+exports.MoneyTransferRepo = MoneyTransferRepo;

package/lib/chevre/repo/transaction/placeOrder.d.ts

@@ -0,0 +1,140 @@
+import type { Connection, FilterQuery } from 'mongoose';
+import * as factory from '../../factory';
+type IKeyOfProjection = 'agent' | 'endDate' | 'expires' | 'project' | 'startDate' | 'status' | 'typeOf' | 'instrument' | 'object' | 'seller' | 'result' | 'potentialActions' | 'error' | 'tasksExportAction';
+export type ITransactionInProgress = Pick<factory.transaction.placeOrder.ITransaction, IKeyOfProjection> & {
+    /**
+     * 取引ID
+     * 常にprojectされる
+     */
+    id: string;
+};
+export type IPlaceOrder = Pick<factory.transaction.placeOrder.ITransaction, IKeyOfProjection> & {
+    /**
+     * 取引ID
+     * 常にprojectされる
+     */
+    id: string;
+};
+type IStartedPlaceOrderFields = 'expires' | 'id' | 'startDate' | 'status';
+export type IStartedPlaceOrder = Pick<factory.transaction.ITransaction<factory.transactionType.PlaceOrder>, IStartedPlaceOrderFields>;
+/**
+ * 注文取引リポジトリ
+ */
+export declare class PlaceOrderRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    static CREATE_MONGO_CONDITIONS(params: factory.transaction.ISearchConditions<factory.transactionType.PlaceOrder>): FilterQuery<import("@chevre/factory/lib/transaction/placeOrder").ITransaction>[];
+    countPlaceOrder(params: factory.transaction.ISearchConditions<factory.transactionType.PlaceOrder>): Promise<{
+        count: number;
+    }>;
+    /**
+     * 取引を検索する
+     */
+    findPlaceOrderTransactions(params: factory.transaction.ISearchConditions<factory.transactionType.PlaceOrder> & {
+        inclusion: IKeyOfProjection[];
+    }): Promise<(Pick<factory.transaction.ITransaction<factory.transactionType.PlaceOrder>, IKeyOfProjection> & {
+        id: string;
+    })[]>;
+    /**
+     * 進行中取引に保管された採用済決済方法を検索する
+     */
+    findInProgressPaymentMethodId(params: {
+        id: string;
+    }): Promise<factory.transaction.placeOrder.IPaymentMethodByPaymentUrl | undefined>;
+    /**
+     * 取引の注文番号を検索する
+     */
+    findInProgressOrderNumberById(params: {
+        id: string;
+    }): Promise<string | undefined>;
+    /**
+     * 取引の確認番号を検索する
+     */
+    findInProgressConfirmationNumberById(params: {
+        id: string;
+        status: {
+            $in: factory.transactionStatusType[];
+        };
+    }): Promise<string | undefined>;
+    /**
+     * 取引期限変更
+     */
+    updateExpires(params: {
+        typeOf: factory.transactionType.PlaceOrder;
+        id: string;
+        expires: Date;
+    }): Promise<void>;
+    /**
+     * 取引オブジェクトを更新
+     * 注文名称など
+     */
+    updateObject(params: {
+        typeOf: factory.transactionType.PlaceOrder;
+        id: string;
+        object?: {
+            name?: string;
+        };
+    }): Promise<void>;
+    /**
+     * 特定の進行中取引を更新する(汎用)
+     */
+    findByIdAndUpdateInProgress(params: {
+        id: string;
+        update: {
+            $set?: {
+                'object.paymentMethods'?: factory.transaction.placeOrder.IPaymentMethodByPaymentUrl;
+            };
+        };
+    }): Promise<void>;
+    /**
+     * 進行中取引のobjectに注文番号を保管する
+     */
+    saveOrderNumberIfNotExist(params: {
+        id: string;
+        orderNumber: string;
+    }): Promise<{
+        modifiedCount: number;
+    }>;
+    saveConfirmationNumberIfNotExist(params: {
+        id: string;
+        status: {
+            $in: factory.transactionStatusType[];
+        };
+        confirmationNumber: string;
+    }): Promise<void>;
+    /**
+     * 進行中の注文取引を取得する
+     */
+    findPlaceOrderInProgressById(params: {
+        typeOf: factory.transactionType.PlaceOrder;
+        id: string;
+    }, inclusion: IKeyOfProjection[]): Promise<ITransactionInProgress>;
+    /**
+     * 特定注文取引参照
+     */
+    findPlaceOrderById(params: {
+        typeOf: factory.transactionType.PlaceOrder;
+        id: string;
+    }, inclusion: IKeyOfProjection[]): Promise<IPlaceOrder>;
+    /**
+     * 取引を開始する
+     */
+    startPlaceOrder(params: factory.transaction.IStartParams<factory.transactionType.PlaceOrder>): Promise<IStartedPlaceOrder>;
+    /**
+     * 取引を確定する
+     */
+    confirmPlaceOrder(params: {
+        typeOf: factory.transactionType.PlaceOrder;
+        id: string;
+        result: factory.transaction.IResult<factory.transactionType.PlaceOrder>;
+        potentialActions: factory.transaction.IPotentialActions<factory.transactionType.PlaceOrder>;
+    }): Promise<void>;
+    /**
+     * 取引を中止する
+     */
+    cancelPlaceOrder(params: {
+        typeOf: factory.transactionType.PlaceOrder;
+        id: string;
+    }): Promise<void>;
+}
+export {};