@chevre/domain 24.0.0-alpha.10 → 24.0.0-alpha.12

package/lib/chevre/service/order/onAssetTransactionStatusChanged/paymentDue2Processing.d.ts

@@ -0,0 +1,21 @@
+import type { AcceptedOfferRepo } from '../../../repo/acceptedOffer';
+import type { OrderRepo } from '../../../repo/order';
+import type { SettingRepo } from '../../../repo/setting';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import { Settings } from '../../../settings';
+declare function paymentDue2Processing(params: {
+    project: {
+        id: string;
+    };
+    confirmationNumber: string;
+    orderNumber: string;
+    useOnOrderStatusChanged: boolean;
+}): (repos: {
+    acceptedOffer: AcceptedOfferRepo;
+    order: OrderRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}, settings: Settings) => Promise<void>;
+export { paymentDue2Processing, };

package/lib/chevre/service/order/onAssetTransactionStatusChanged/paymentDue2Processing.js

@@ -0,0 +1,108 @@
+"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.paymentDue2Processing = paymentDue2Processing;
+const debug_1 = __importDefault(require("debug"));
+const findPlaceOrderTransaction_1 = require("../findPlaceOrderTransaction");
+const onOrderStatusChanged_1 = require("../onOrderStatusChanged");
+const factory = __importStar(require("../../../factory"));
+const debug = (0, debug_1.default)('chevre-domain:service:order');
+function paymentDue2Processing(params) {
+    return async (repos, settings) => {
+        const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
+            project: { id: params.project.id },
+            confirmationNumber: params.confirmationNumber,
+            orderNumber: params.orderNumber
+        })(repos);
+        // const existingOrder: Pick<factory.order.IOrder, 'project'> = await repos.order.projectFieldsByOrderNumber({
+        //     orderNumber: params.orderNumber,
+        //     project: { id: params.project.id },
+        //     inclusion: ['project']
+        // });
+        let order;
+        try {
+            order = await repos.order.changeStatus({
+                project: { id: params.project.id },
+                orderNumber: params.orderNumber,
+                orderStatus: factory.orderStatus.OrderProcessing,
+                previousOrderStatus: factory.orderStatus.OrderPaymentDue
+            });
+        }
+        catch (error) {
+            let throwsError = true;
+            // すでにステータスが進行していた場合、OrderPaymentDue->OrderProcessingの処理自体は成功しているので、後処理を続行する
+            order = await repos.order.projectFieldsByOrderNumber({
+                orderNumber: params.orderNumber,
+                project: { id: params.project.id },
+                inclusion: [
+                    'orderNumber', 'broker', 'confirmationNumber', 'customer', 'dateReturned',
+                    'name', 'orderDate', 'orderStatus', 'orderedItem', 'paymentMethods',
+                    'previousOrderStatus', 'price', 'priceCurrency', 'project', 'returner', 'seller', 'typeOf'
+                ] // explicit projection(2024-07-25~)
+            });
+            if (order.orderStatus === factory.orderStatus.OrderInTransit
+                || order.orderStatus === factory.orderStatus.OrderDelivered
+                || order.orderStatus === factory.orderStatus.OrderReturned) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        if (params.useOnOrderStatusChanged) {
+            // 全acceptedOffersを検索(2023-12-08~)
+            // const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber(
+            //     {
+            //         orderNumber: { $eq: order.orderNumber },
+            //         project: { id: { $eq: params.project.id } }
+            //     },
+            //     ['itemOffered', 'offeredThrough']
+            // );
+            const { numAcceptedOffers } = await repos.acceptedOffer.countByOrderNumber({
+                orderNumber: { $eq: order.orderNumber },
+                project: { id: { $eq: params.project.id } }
+            });
+            const itemOfferedTypeOfs = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.typeOf');
+            const serialNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
+            const offeredThroughIdentifier = (await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.offeredThrough.identifier')).shift();
+            debug('onAssetTransactionStatusChanged paymentDue2Processing: calling onOrderProcessing...', 'numAcceptedOffers:', numAcceptedOffers, 'itemOfferedTypeOfs:', itemOfferedTypeOfs, 'serialNumbers:', serialNumbers, 'offeredThroughIdentifier:', offeredThroughIdentifier);
+            await (0, onOrderStatusChanged_1.onOrderProcessing)({
+                order: {
+                    ...order,
+                    // acceptedOffers,
+                    numAcceptedOffers,
+                    itemOfferedTypeOf: itemOfferedTypeOfs[0], // 1つしかない前提
+                    serialNumbers,
+                    offeredThroughIdentifier,
+                    orderStatus: factory.orderStatus.OrderProcessing // 強制的にOrderProcessingとして処理する
+                },
+                placeOrderTransaction
+            })(repos, settings);
+        }
+    };
+}

package/lib/chevre/service/order/onAssetTransactionStatusChanged.d.ts

@@ -4,30 +4,18 @@ import type { OrderRepo } from '../../repo/order';
 import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
+import { paymentDue2Processing } from './onAssetTransactionStatusChanged/paymentDue2Processing';
 import * as factory from '../../factory';
 import { Settings } from '../../settings';
-declare function onAssetTransactionStatusChanged(params: factory.task.IData<factory.taskName.OnAssetTransactionStatusChanged>): (repos: {
+interface IOnAssetTransactionStatusChangedRepos {
     acceptedOffer: AcceptedOfferRepo;
     assetTransaction: AssetTransactionRepo;
     order: OrderRepo;
     setting: SettingRepo;
     task: TaskRepo;
     placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<void>;
-declare function paymentDue2Processing(params: {
-    project: {
-        id: string;
-    };
-    confirmationNumber: string;
-    orderNumber: string;
-    useOnOrderStatusChanged: boolean;
-}): (repos: {
-    acceptedOffer: AcceptedOfferRepo;
-    order: OrderRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
-    placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<void>;
+}
+declare function onAssetTransactionStatusChanged(params: factory.task.IData<factory.taskName.OnAssetTransactionStatusChanged>): (repos: IOnAssetTransactionStatusChangedRepos, settings: Settings) => Promise<void>;
 declare function processing2inTransit(params: {
     project: {
         id: string;
@@ -39,4 +27,4 @@ declare function processing2inTransit(params: {
     task: TaskRepo;
     placeOrder: PlaceOrderRepo;
 }, settings: Settings) => Promise<void>;
-export { onAssetTransactionStatusChanged, paymentDue2Processing, processing2inTransit };
+export { IOnAssetTransactionStatusChangedRepos, onAssetTransactionStatusChanged, paymentDue2Processing, processing2inTransit };

package/lib/chevre/service/order/onAssetTransactionStatusChanged.js

@@ -26,12 +26,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.paymentDue2Processing = void 0;
 exports.onAssetTransactionStatusChanged = onAssetTransactionStatusChanged;
-exports.paymentDue2Processing = paymentDue2Processing;
 exports.processing2inTransit = processing2inTransit;
 const debug_1 = __importDefault(require("debug"));
 const findPlaceOrderTransaction_1 = require("./findPlaceOrderTransaction");
 const onOrderStatusChanged_1 = require("./onOrderStatusChanged");
+const paymentDue2Processing_1 = require("./onAssetTransactionStatusChanged/paymentDue2Processing");
+Object.defineProperty(exports, "paymentDue2Processing", { enumerable: true, get: function () { return paymentDue2Processing_1.paymentDue2Processing; } });
 const factory = __importStar(require("../../factory"));
 const debug = (0, debug_1.default)('chevre-domain:service:order');
 function onAssetTransactionStatusChanged(params) {
@@ -59,7 +61,7 @@ function onAssetTransactionStatusChanged(params) {
                             // PayTransactionのステータス検証
                             const processable = await isProcessable({ project: { id: params.project.id }, orderNumber })(repos);
                             if (processable) {
-                                await paymentDue2Processing({
+                                await (0, paymentDue2Processing_1.paymentDue2Processing)({
                                     project: { id: params.project.id },
                                     confirmationNumber,
                                     orderNumber,
@@ -211,80 +213,6 @@ function isProcessable(params) {
         return allPayTransactionConfirmed;
     };
 }
-function paymentDue2Processing(params) {
-    return async (repos, settings) => {
-        const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
-            project: { id: params.project.id },
-            confirmationNumber: params.confirmationNumber,
-            orderNumber: params.orderNumber
-        })(repos);
-        // const existingOrder: Pick<factory.order.IOrder, 'project'> = await repos.order.projectFieldsByOrderNumber({
-        //     orderNumber: params.orderNumber,
-        //     project: { id: params.project.id },
-        //     inclusion: ['project']
-        // });
-        let order;
-        try {
-            order = await repos.order.changeStatus({
-                project: { id: params.project.id },
-                orderNumber: params.orderNumber,
-                orderStatus: factory.orderStatus.OrderProcessing,
-                previousOrderStatus: factory.orderStatus.OrderPaymentDue
-            });
-        }
-        catch (error) {
-            let throwsError = true;
-            // すでにステータスが進行していた場合、OrderPaymentDue->OrderProcessingの処理自体は成功しているので、後処理を続行する
-            order = await repos.order.projectFieldsByOrderNumber({
-                orderNumber: params.orderNumber,
-                project: { id: params.project.id },
-                inclusion: [
-                    'orderNumber', 'broker', 'confirmationNumber', 'customer', 'dateReturned',
-                    'name', 'orderDate', 'orderStatus', 'orderedItem', 'paymentMethods',
-                    'previousOrderStatus', 'price', 'priceCurrency', 'project', 'returner', 'seller', 'typeOf'
-                ] // explicit projection(2024-07-25~)
-            });
-            if (order.orderStatus === factory.orderStatus.OrderInTransit
-                || order.orderStatus === factory.orderStatus.OrderDelivered
-                || order.orderStatus === factory.orderStatus.OrderReturned) {
-                throwsError = false;
-            }
-            if (throwsError) {
-                throw error;
-            }
-        }
-        if (params.useOnOrderStatusChanged) {
-            // 全acceptedOffersを検索(2023-12-08~)
-            // const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber(
-            //     {
-            //         orderNumber: { $eq: order.orderNumber },
-            //         project: { id: { $eq: params.project.id } }
-            //     },
-            //     ['itemOffered', 'offeredThrough']
-            // );
-            const { numAcceptedOffers } = await repos.acceptedOffer.countByOrderNumber({
-                orderNumber: { $eq: order.orderNumber },
-                project: { id: { $eq: params.project.id } }
-            });
-            const itemOfferedTypeOfs = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.typeOf');
-            const serialNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
-            const offeredThroughIdentifier = (await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.offeredThrough.identifier')).shift();
-            debug('onAssetTransactionStatusChanged paymentDue2Processing: calling onOrderProcessing...', 'numAcceptedOffers:', numAcceptedOffers, 'itemOfferedTypeOfs:', itemOfferedTypeOfs, 'serialNumbers:', serialNumbers, 'offeredThroughIdentifier:', offeredThroughIdentifier);
-            await (0, onOrderStatusChanged_1.onOrderProcessing)({
-                order: {
-                    ...order,
-                    // acceptedOffers,
-                    numAcceptedOffers,
-                    itemOfferedTypeOf: itemOfferedTypeOfs[0], // 1つしかない前提
-                    serialNumbers,
-                    offeredThroughIdentifier,
-                    orderStatus: factory.orderStatus.OrderProcessing // 強制的にOrderProcessingとして処理する
-                },
-                placeOrderTransaction
-            })(repos, settings);
-        }
-    };
-}
 function cancelOrderIfExist(params) {
     return async (repos) => {
         if (params.paymentMethodId.length === 0) {

package/lib/chevre/service/order/placeOrder.d.ts

@@ -8,6 +8,16 @@ import type { TaskRepo } from '../../repo/task';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import * as factory from '../../factory';
 import { Settings } from '../../settings';
+interface IPlaceOrderRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    order: OrderRepo;
+    orderInTransaction: OrderInTransactionRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
 /**
  * 注文を作成する
  */
@@ -21,16 +31,7 @@ declare function placeOrder(params: {
         orderNumber: string;
     };
     useOnOrderStatusChanged: boolean;
-}): (repos: {
-    acceptedOffer: AcceptedOfferRepo;
-    accountingReport: AccountingReportRepo;
-    action: ActionRepo;
-    order: OrderRepo;
-    orderInTransaction: OrderInTransactionRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
-    placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<{
+}): (repos: IPlaceOrderRepos, settings: Settings) => Promise<{
     order: factory.transaction.placeOrder.IOrderAsResult;
 }>;
-export { placeOrder };
+export { IPlaceOrderRepos, placeOrder };

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

@@ -2,12 +2,9 @@
  * 注文サービス
  */
 import { confirmPayTransaction } from './order/confirmPayTransaction';
-import { deleteOrder } from './order/deleteOrder';
-import { onAssetTransactionStatusChanged, paymentDue2Processing } from './order/onAssetTransactionStatusChanged';
-import { onOrderProcessing, processOrder } from './order/onOrderStatusChanged';
+import { paymentDue2Processing } from './order/onAssetTransactionStatusChanged';
+import { processOrder } from './order/onOrderStatusChanged';
 import { onOrderUpdated } from './order/onOrderUpdated';
-import { payOrder } from './order/payOrder';
 import { placeOrder } from './order/placeOrder';
 import { placeOrderWithoutTransaction } from './order/placeOrderWithoutTransaction';
-import { sendOrder } from './order/sendOrder';
-export { confirmPayTransaction, deleteOrder, onAssetTransactionStatusChanged, onOrderProcessing, onOrderUpdated, paymentDue2Processing, payOrder, placeOrder, placeOrderWithoutTransaction, processOrder, sendOrder };
+export { confirmPayTransaction, onOrderUpdated, paymentDue2Processing, placeOrder, placeOrderWithoutTransaction, processOrder, };

package/lib/chevre/service/order.js

@@ -1,26 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendOrder = exports.processOrder = exports.placeOrderWithoutTransaction = exports.placeOrder = exports.payOrder = exports.paymentDue2Processing = exports.onOrderUpdated = exports.onOrderProcessing = exports.onAssetTransactionStatusChanged = exports.deleteOrder = exports.confirmPayTransaction = void 0;
+exports.processOrder = exports.placeOrderWithoutTransaction = exports.placeOrder = exports.paymentDue2Processing = exports.onOrderUpdated = exports.confirmPayTransaction = void 0;
 /**
  * 注文サービス
  */
 const confirmPayTransaction_1 = require("./order/confirmPayTransaction");
 Object.defineProperty(exports, "confirmPayTransaction", { enumerable: true, get: function () { return confirmPayTransaction_1.confirmPayTransaction; } });
-const deleteOrder_1 = require("./order/deleteOrder");
-Object.defineProperty(exports, "deleteOrder", { enumerable: true, get: function () { return deleteOrder_1.deleteOrder; } });
+// import { deleteOrder } from './order/deleteOrder';
 const onAssetTransactionStatusChanged_1 = require("./order/onAssetTransactionStatusChanged");
-Object.defineProperty(exports, "onAssetTransactionStatusChanged", { enumerable: true, get: function () { return onAssetTransactionStatusChanged_1.onAssetTransactionStatusChanged; } });
 Object.defineProperty(exports, "paymentDue2Processing", { enumerable: true, get: function () { return onAssetTransactionStatusChanged_1.paymentDue2Processing; } });
 const onOrderStatusChanged_1 = require("./order/onOrderStatusChanged");
-Object.defineProperty(exports, "onOrderProcessing", { enumerable: true, get: function () { return onOrderStatusChanged_1.onOrderProcessing; } });
 Object.defineProperty(exports, "processOrder", { enumerable: true, get: function () { return onOrderStatusChanged_1.processOrder; } });
 const onOrderUpdated_1 = require("./order/onOrderUpdated");
 Object.defineProperty(exports, "onOrderUpdated", { enumerable: true, get: function () { return onOrderUpdated_1.onOrderUpdated; } });
-const payOrder_1 = require("./order/payOrder");
-Object.defineProperty(exports, "payOrder", { enumerable: true, get: function () { return payOrder_1.payOrder; } });
+// import { payOrder } from './order/payOrder';
 const placeOrder_1 = require("./order/placeOrder");
 Object.defineProperty(exports, "placeOrder", { enumerable: true, get: function () { return placeOrder_1.placeOrder; } });
 const placeOrderWithoutTransaction_1 = require("./order/placeOrderWithoutTransaction");
 Object.defineProperty(exports, "placeOrderWithoutTransaction", { enumerable: true, get: function () { return placeOrderWithoutTransaction_1.placeOrderWithoutTransaction; } });
-const sendOrder_1 = require("./order/sendOrder");
-Object.defineProperty(exports, "sendOrder", { enumerable: true, get: function () { return sendOrder_1.sendOrder; } });

package/lib/chevre/service/payment/any/{fixOrderAsNeeded.d.ts → authorize/fixOrderAsNeeded.d.ts}

@@ -1,8 +1,8 @@
-import * as factory from '../../../factory';
-import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
-import type { OrderNumberRepo } from '../../../repo/orderNumber';
-import type { ProjectRepo } from '../../../repo/project';
-import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import * as factory from '../../../../factory';
+import type { ConfirmationNumberRepo } from '../../../../repo/confirmationNumber';
+import type { OrderNumberRepo } from '../../../../repo/orderNumber';
+import type { ProjectRepo } from '../../../../repo/project';
+import type { PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
 declare function fixOrderAsNeeded(params: {
     project: {
         id: string;

package/lib/chevre/service/payment/any/{fixOrderAsNeeded.js → authorize/fixOrderAsNeeded.js}

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fixOrderAsNeeded = fixOrderAsNeeded;
-const factory = __importStar(require("../../../factory"));
-const publishConfirmationNumberIfNotExist_1 = require("../../transaction/placeOrder/publishConfirmationNumberIfNotExist");
-const issueOrderNumberIfNotExist_1 = require("../../transaction/placeOrder/issueOrderNumberIfNotExist");
+const factory = __importStar(require("../../../../factory"));
+const publishConfirmationNumberIfNotExist_1 = require("../../../transaction/placeOrder/publishConfirmationNumberIfNotExist");
+const issueOrderNumberIfNotExist_1 = require("../../../transaction/placeOrder/issueOrderNumberIfNotExist");
 function fixOrderAsNeeded(params) {
     return async (repos) => {
         const orderDate = new Date();

package/lib/chevre/service/payment/any/authorize.d.ts

@@ -0,0 +1,90 @@
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { ActionRepo } from '../../../repo/action';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { AuthorizationRepo } from '../../../repo/authorization';
+import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
+import type { CredentialsRepo } from '../../../repo/credentials';
+import type { EventRepo } from '../../../repo/event';
+import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import type { OrderNumberRepo } from '../../../repo/orderNumber';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { PotentialActionRepo } from '../../../repo/potentialAction';
+import type { ProductRepo } from '../../../repo/product';
+import type { ProjectRepo } from '../../../repo/project';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import type { TicketRepo } from '../../../repo/ticket';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import type { TransactionNumberRepo } from '../../../repo/transactionNumber';
+interface IAuthorizeRepos {
+    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    authorization: AuthorizationRepo;
+    confirmationNumber: ConfirmationNumberRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    orderNumber: OrderNumberRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    potentialAction: PotentialActionRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    task: TaskRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+type IAuthorizeOperation<T> = (repos: IAuthorizeRepos, settings: Settings) => Promise<T>;
+type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail & {
+    ticketToken?: string;
+};
+/**
+ * 決済承認
+ * CreditCard,MovieTicket -> 決済承認タスクから呼ばれる
+ * FaceToFace,PaymentCard -> apiから呼ばれる
+ */
+declare function authorize(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: IObjectWithoutDetail;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+    location?: factory.action.trade.pay.ILocation;
+    options: {
+        /**
+         * アクション失敗時に即時に決済取引を中止するかどうか
+         */
+        useCancelPayTransactionOnFailed: boolean;
+        checkedAction: {
+            id: string;
+        };
+    };
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+    /**
+     * ツールとしての対応決済方法オファー
+     */
+    instrument: factory.action.trade.pay.IAcceptedPaymentMethodOfferAsInstrument[];
+}): IAuthorizeOperation<{
+    /**
+     * 承認アクションID
+     */
+    id: string;
+}>;
+export { authorize, IAuthorizeRepos };