@chevre/domain 24.0.0-alpha.4 → 24.0.0-alpha.40

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

@@ -4,18 +4,18 @@ import type { OrderRepo } from '../../repo/order';
 import type { OwnershipInfoRepo } from '../../repo/ownershipInfo';
 import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
-import type { TransactionRepo } from '../../repo/transaction';
+import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import * as factory from '../../factory';
-import { Settings } from '../../settings';
-type ISendOperation<T> = (repos: {
+interface ISendOrderRepos {
     acceptedOffer: AcceptedOfferRepo;
     action: ActionRepo;
     order: OrderRepo;
     ownershipInfo: OwnershipInfoRepo;
     setting: SettingRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
-}, settings: Settings) => Promise<T>;
+    placeOrder: PlaceOrderRepo;
+}
+type ISendOperation<T> = (repos: ISendOrderRepos) => Promise<T>;
 /**
  * 注文を配送する
  */
@@ -35,4 +35,4 @@ declare function sendOrder(params: {
     };
     useOnOrderStatusChanged: boolean;
 }): ISendOperation<void>;
-export { sendOrder };
+export { ISendOrderRepos, sendOrder };

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

@@ -30,9 +30,10 @@ exports.sendOrder = sendOrder;
 const debug_1 = __importDefault(require("debug"));
 // import { createMaskedCustomer } from '../../factory/order';
 const factory_1 = require("../delivery/factory");
-const findPlaceOrderTransaction_1 = require("./findPlaceOrderTransaction");
+// import { findPlaceOrderTransaction } from './findPlaceOrderTransaction';
 const onOrderStatusChanged_1 = require("./onOrderStatusChanged");
 const factory = __importStar(require("../../factory"));
+// import { Settings } from '../../settings';
 const debug = (0, debug_1.default)('chevre-domain:service:order');
 /**
  * 注文を配送する
@@ -59,11 +60,11 @@ function sendOrder(params) {
         try {
             const orderNumber = params.object.orderNumber;
             const confirmationNumber = params.object.confirmationNumber;
-            const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
-                project: { id: params.project.id },
-                confirmationNumber,
-                orderNumber
-            })({ transaction: repos.transaction });
+            // const placeOrderTransaction = await findPlaceOrderTransaction({
+            //     project: { id: params.project.id },
+            //     confirmationNumber,
+            //     orderNumber
+            // })(repos);
             // 注文取得
             let order = await repos.order.projectFieldsByOrderNumber({
                 orderNumber,
@@ -113,10 +114,13 @@ function sendOrder(params) {
             // 所有権生成を最小化(2024-03-01~)
             let createOwnerships = false;
             switch (order.customer.typeOf) {
-                case factory.creativeWorkType.WebApplication:
+                case factory.personType.Person:
+                    createOwnerships = true; // Personのみに限定(2026-03-15~)
                     break;
+                // case factory.creativeWorkType.WebApplication:
+                //     break;
                 default:
-                    createOwnerships = true;
+                // createOwnerships = true;
             }
             try {
                 const offerIndexBase = (limit * (page - 1));
@@ -180,8 +184,8 @@ function sendOrder(params) {
                             orderStatus: factory.orderStatus.OrderDelivered,
                             price: order.price,
                             priceCurrency: order.priceCurrency
-                        },
-                        placeOrderTransaction
+                        }
+                        // placeOrderTransaction
                     })(repos);
                 }
                 else {

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 { TransactionRepo } from '../../../repo/transaction';
+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;
@@ -10,7 +10,7 @@ declare function fixOrderAsNeeded(params: {
     purpose: factory.action.authorize.paymentMethod.any.IPurpose;
 }): (repos: {
     project: ProjectRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
     confirmationNumber: ConfirmationNumberRepo;
     orderNumber: OrderNumberRepo;
 }) => Promise<{

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 publishOrderNumberIfNotExist_1 = require("../../transaction/placeOrder/publishOrderNumberIfNotExist");
+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();
@@ -38,13 +38,10 @@ function fixOrderAsNeeded(params) {
             id: params.purpose.id,
             status: { $in: [factory.transactionStatusType.InProgress] },
             object: { orderDate }
-        })({
-            confirmationNumber: repos.confirmationNumber,
-            transaction: repos.transaction
-        });
+        })(repos);
         // }
         // publish orderNumber(2025-02-14~)
-        const orderNumber = await (0, publishOrderNumberIfNotExist_1.publishOrderNumberIfNotExist)({
+        const orderNumber = await (0, issueOrderNumberIfNotExist_1.issueOrderNumberIfNotExist)({
             project: { id: params.project.id },
             id: params.purpose.id,
             object: { orderDate }

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

@@ -1,16 +1,19 @@
 import * as factory from '../../../../factory';
-import type { ActionRepo } from '../../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../../repo/action/authorizePaymentMethod';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
-import type { ITransactionInProgress, TransactionRepo } from '../../../../repo/transaction';
+import type { ITransactionInProgress, PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
 import type { TransactionNumberRepo } from '../../../../repo/transactionNumber';
 import * as PayTransactionService from '../../../assetTransaction/pay';
 import { IInvoiceByTicketToken } from '../factory';
 interface IFixTransactionNumberRepos {
-    action: ActionRepo;
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
     authorization: AuthorizationRepo;
     ticket: TicketRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
     transactionNumber: TransactionNumberRepo;
 }
 type IFixTransactionNumberOperation<T> = (repos: IFixTransactionNumberRepos) => Promise<T>;
@@ -22,7 +25,7 @@ type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWi
  */
 declare function fixTransactionNumber(params: {
     object: IObjectWithoutDetail;
-    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
+    transaction: Pick<ITransactionInProgress, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
     paymentServiceType: factory.service.paymentService.PaymentServiceType;
 }): IFixTransactionNumberOperation<{
     transactionNumber: string;

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

@@ -1,8 +1,9 @@
 import * as factory from '../../../../factory';
-import type { ActionRepo } from '../../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../../repo/action/authorizePaymentMethod';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
-import type { ITransactionInProgress, TransactionRepo } from '../../../../repo/transaction';
+import type { ITransactionInProgress, PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
 import * as PayTransactionService from '../../../assetTransaction/pay';
 import type { IInvoiceByTicketToken } from '../factory';
 type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail;
@@ -10,19 +11,22 @@ interface IAcceptAction2ticketResult {
     invoiceByTicketToken: IInvoiceByTicketToken;
     ticketToken: string;
 }
+interface IHandlePrePublishedPaymentMethodIdOnAuthorizingRepos {
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    authorization: AuthorizationRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+}
 /**
  * 決済承認前の決済採用アクションを参照する
  */
 declare function handlePrePublishedPaymentMethodIdOnAuthorizing(params: {
     object: Pick<IObjectWithoutDetail, 'amount' | 'issuedThrough' | 'paymentMethod' | 'referencesOrder'>;
     prePublishedPaymentMethodId: string;
-    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
-}): (repos: {
-    action: ActionRepo;
-    authorization: AuthorizationRepo;
-    ticket: TicketRepo;
-    transaction: TransactionRepo;
-}) => Promise<{
+    transaction: Pick<ITransactionInProgress, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
+}): (repos: IHandlePrePublishedPaymentMethodIdOnAuthorizingRepos) => Promise<{
     authorizeParams?: {
         creditCard: factory.action.authorize.paymentMethod.any.ICreditCard;
         paymentMethodByTransaction: factory.transaction.placeOrder.IPaymentMethodByPaymentUrl;
@@ -37,4 +41,4 @@ declare function handlePrePublishedPaymentMethodIdOnAuthorizing(params: {
     authorizeParams?: never;
     acceptAction2ticketResult?: never;
 }>;
-export { handlePrePublishedPaymentMethodIdOnAuthorizing };
+export { IHandlePrePublishedPaymentMethodIdOnAuthorizingRepos, handlePrePublishedPaymentMethodIdOnAuthorizing };

package/lib/chevre/service/payment/any/authorize/handlePrePublishedPaymentMethodIdOnAuthorizing.js

@@ -122,27 +122,35 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
         let acceptPayAction;
         // transaction.objectへのアクセス回避(2024-05-30~)
         // const paymentMethodByTransaction = transaction.object.paymentMethods;
-        const paymentMethodByTransaction = await repos.transaction.findInProgressPaymentMethodId({ id: params.transaction.id });
+        const paymentMethodByTransaction = await repos.placeOrder.findInProgressPaymentMethodId({ id: params.transaction.id });
         if (params.prePublishedPaymentMethodId === paymentMethodByTransaction?.paymentMethodId) {
             // check existence of acceptAction when authorizing payment(2024-06-01~)
-            acceptPayAction = (await repos.action.search({
-                limit: 1,
-                page: 1,
-                project: { id: { $eq: params.transaction.project.id } },
-                typeOf: { $eq: factory.actionType.AcceptAction },
-                actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
-                purpose: { id: { $in: [params.transaction.id] } },
-                object: {
-                    transactionNumber: { $eq: params.prePublishedPaymentMethodId },
-                    typeOf: { $eq: factory.assetTransactionType.Pay }
-                }
+            // acceptPayAction = (<Pick<IAcceptPayAction, 'object' | 'result' | 'id' | 'instrument'>[]>await repos.action.search<factory.actionType.AcceptAction>(
+            //     {
+            //         limit: 1,
+            //         page: 1,
+            //         project: { id: { $eq: params.transaction.project.id } },
+            //         typeOf: { $eq: factory.actionType.AcceptAction },
+            //         actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
+            //         purpose: { id: { $in: [params.transaction.id] } },
+            //         object: {
+            //             transactionNumber: { $eq: params.prePublishedPaymentMethodId },
+            //             typeOf: { $eq: factory.assetTransactionType.Pay }
+            //         }
+            //     },
+            //     ['object', 'result', 'instrument']
+            // )).shift();
+            acceptPayAction = (await repos.acceptPayAction.findCompletedAcceptActionsByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                purpose: { id: params.transaction.id },
+                object: { transactionNumber: params.prePublishedPaymentMethodId }
             }, ['object', 'result', 'instrument'])).shift();
             if (acceptPayAction === undefined) {
                 throw new factory.errors.NotFound(factory.actionType.AcceptAction);
             }
             debug('acceptPayAction found:', acceptPayAction.id);
             // find recipe(2024-06-02~)
-            const actionRecipe = await repos.action.findRecipeByAction({
+            const actionRecipe = await repos.acceptPayAction.findRecipeByAction({
                 project: { id: params.transaction.project.id },
                 recipeFor: { id: acceptPayAction.id }
             });
@@ -169,13 +177,22 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
                 throw new factory.errors.Argument('paymentMethodId', 'pendingPaymentAgencyTransaction not found');
             }
             // 既に承認済であれば何もしない(2023-05-15~)
-            const existingCompletedAuthorizeActions = await repos.action.searchByPurpose({
-                typeOf: factory.actionType.AuthorizeAction,
+            // const existingCompletedAuthorizeActions = <IAuthorizePaymentAction[]>
+            //     await repos.action.searchByPurpose<factory.actionType.AuthorizeAction>({
+            //         typeOf: factory.actionType.AuthorizeAction,
+            //         purpose: { id: params.transaction.id, typeOf: params.transaction.typeOf },
+            //         actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus },
+            //         object: {
+            //             paymentMethodId: { $eq: params.prePublishedPaymentMethodId },
+            //             typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment }
+            //         },
+            //         sort: { startDate: factory.sortType.Ascending }
+            //     });
+            const existingCompletedAuthorizeActions = await repos.authorizePaymentMethodAction.findAuthorizePaymentMethodActionsByPurpose({
                 purpose: { id: params.transaction.id, typeOf: params.transaction.typeOf },
                 actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus },
                 object: {
-                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId },
-                    typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment }
+                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId }
                 },
                 sort: { startDate: factory.sortType.Ascending }
             });

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

@@ -0,0 +1,98 @@
+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 { CheckMovieTicketActionRepo } from '../../../repo/action/checkMovieTicket';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
+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;
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    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 };