@chevre/domain 23.2.0-alpha.9 → 24.0.0-alpha.0

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeAccount.js

@@ -0,0 +1,62 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAuthorizeAccount = processAuthorizeAccount;
+const factory = __importStar(require("../../../../factory"));
+const PaymentCardPayment = __importStar(require("../../../payment/paymentCard"));
+const validation_1 = require("./account/validation");
+function processAuthorizeAccount(params, transaction, paymentServiceId) {
+    return async (repos) => {
+        const amount = params.object.paymentMethod?.amount;
+        if (typeof amount !== 'number') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod?.amount');
+        }
+        await (0, validation_1.validateAccount)(params)(repos);
+        const { pendingTransaction, currency, accountNumber } = await PaymentCardPayment.authorize(params, paymentServiceId)(repos);
+        const totalPaymentDue = {
+            typeOf: 'MonetaryAmount',
+            currency,
+            value: amount
+        };
+        const savingPendingTransaction = {
+            typeOf: pendingTransaction.typeOf,
+            id: pendingTransaction.id,
+            transactionNumber: pendingTransaction.transactionNumber,
+            object: { fromLocation: { accountNumber } }
+        };
+        return saveAuthorizeResult({
+            id: transaction.id,
+            update: {
+                'object.paymentMethod.totalPaymentDue': totalPaymentDue,
+                'object.pendingTransaction': savingPendingTransaction
+            }
+        })(repos);
+    };
+}
+function saveAuthorizeResult(params) {
+    return async (repos) => {
+        return repos.assetTransaction.findByIdAndUpdateInProgress(params);
+    };
+}

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeCreditCard.d.ts

@@ -0,0 +1,29 @@
+import * as factory from '../../../../factory';
+import { Settings } from '../../../../settings';
+import type { ActionRepo } from '../../../../repo/action';
+import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
+import type { PaymentServiceRepo } from '../../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../../repo/sellerPaymentAccepted';
+import * as CreditCardPayment from '../../../payment/creditCard';
+export declare function processAuthorizeCreditCard(params: factory.assetTransaction.pay.IStartParamsWithoutDetail, transaction: {
+    id: string;
+}, paymentServiceId: string, options: {
+    pendingPaymentAgencyTransaction?: CreditCardPayment.IPaymentAgencyTransaction;
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+}): (repos: {
+    action: ActionRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    assetTransaction: AssetTransactionRepo;
+}, settings: Settings) => Promise<void>;

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeCreditCard.js

@@ -0,0 +1,54 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAuthorizeCreditCard = processAuthorizeCreditCard;
+const CreditCardPayment = __importStar(require("../../../payment/creditCard"));
+function processAuthorizeCreditCard(params, transaction, paymentServiceId, options) {
+    return async (repos, settings) => {
+        await CreditCardPayment.authorize({ ...params, id: transaction.id }, paymentServiceId, {
+            processPublishPaymentUrl: false,
+            executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {}, // タスク関連付け(2024-05-18~)
+            ...(options.pendingPaymentAgencyTransaction !== undefined)
+                ? { pendingPaymentAgencyTransaction: options.pendingPaymentAgencyTransaction }
+                : undefined
+        })(repos, settings);
+        // ↓discontinue(2024-06-14~)
+        // return saveAuthorizeResult({
+        //     id: transaction.id,
+        //     update: {
+        //         'object.accountId': authorizeResult.accountId,
+        //         'object.paymentMethod.accountId': authorizeResult.accountId,
+        //         'object.paymentMethod.paymentMethodId': authorizeResult.paymentMethodId,
+        //         'object.entryTranArgs': authorizeResult.entryTranArgs,
+        //         'object.entryTranResult': authorizeResult.entryTranResult,
+        //         'object.execTranArgs': authorizeResult.execTranArgs,
+        //         'object.execTranResult': authorizeResult.execTranResult,
+        //         ...(authorizeResult.secureTran2Result !== undefined)
+        //             ? { 'object.secureTran2Result': authorizeResult.secureTran2Result }
+        //             : undefined
+        //     }
+        // })(repos);
+    };
+}

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeMovieTicket.d.ts

@@ -0,0 +1,42 @@
+import * as factory from '../../../../factory';
+import { Settings } from '../../../../settings';
+import type { AccountingReportRepo } from '../../../../repo/accountingReport';
+import type { ActionRepo } from '../../../../repo/action';
+import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
+import type { CredentialsRepo } from '../../../../repo/credentials';
+import type { EventRepo } from '../../../../repo/event';
+import type { PaymentServiceRepo } from '../../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../../repo/task';
+export declare function processAuthorizeMovieTicket(params: factory.assetTransaction.pay.IStartParamsWithoutDetail, transaction: factory.assetTransaction.pay.ITransaction, paymentServiceId: string, options: {
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+    purpose: {
+        /**
+         * placeOrder ID
+         */
+        id?: string;
+    };
+    checkedAction: {
+        id: string;
+    };
+}): (repos: {
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    assetTransaction: AssetTransactionRepo;
+    task: TaskRepo;
+}, settings: Settings) => Promise<factory.assetTransaction.pay.ITransaction>;

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeMovieTicket.js

@@ -0,0 +1,45 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAuthorizeMovieTicket = processAuthorizeMovieTicket;
+const MovieTicketPayment = __importStar(require("../../../payment/movieTicket"));
+function processAuthorizeMovieTicket(params, transaction, paymentServiceId, 
+// useCheckByIdentifierIfNotYet: boolean,
+options) {
+    return async (repos, settings) => {
+        // const { accountsReceivablesByServiceType } = await MovieTicketPayment.authorize(
+        //     params, transaction, paymentServiceId, options
+        // )(repos, settings);
+        await MovieTicketPayment.authorize(params, transaction, paymentServiceId, options)(repos, settings);
+        return transaction;
+        // discontinue(2024-12-17~)
+        // return saveAuthorizeResult({
+        //     id: transaction.id,
+        //     update: {
+        //         'object.accountsReceivablesByServiceType': accountsReceivablesByServiceType // 認証レスポンスより計上金額を保管(2023-05-15~)
+        //     }
+        // })(repos);
+    };
+}

package/lib/chevre/service/assetTransaction/pay/start.d.ts

@@ -0,0 +1,60 @@
+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 { CredentialsRepo } from '../../../repo/credentials';
+import type { EventRepo } from '../../../repo/event';
+import type { EventSeriesRepo } from '../../../repo/eventSeries';
+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 { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import { IPaymentAgencyTransaction } from '../../payment/creditCard';
+export interface IStartOperationRepos {
+    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    potentialAction: PotentialActionRepo;
+    product: ProductRepo;
+    assetTransaction: AssetTransactionRepo;
+    task: TaskRepo;
+}
+export type IStartOperation<T> = (repos: IStartOperationRepos, settings: Settings) => Promise<T>;
+export { IPaymentAgencyTransaction };
+/**
+ * 取引開始
+ */
+export declare function start(params: factory.assetTransaction.pay.IStartParamsWithoutDetail & {
+    instrument: factory.action.trade.pay.IPlaceOrderRelatedInstrument[];
+}, options: {
+    pendingPaymentAgencyTransaction?: IPaymentAgencyTransaction;
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+    purpose: {
+        /**
+         * placeOrder ID
+         */
+        id?: string;
+    };
+    checkedAction: {
+        id: string;
+    };
+}): IStartOperation<Pick<factory.assetTransaction.pay.ITransaction, 'id' | 'object'>>;

package/lib/chevre/service/assetTransaction/pay/start.js

@@ -0,0 +1,162 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = start;
+const factory = __importStar(require("../../../factory"));
+const fixInformAction_1 = require("../fixInformAction");
+const validateAcceptedPaymentMethodIfNeeded_1 = require("./start/preStart/validateAcceptedPaymentMethodIfNeeded");
+const validateSeller_1 = require("./start/preStart/validateSeller");
+const factory_1 = require("./start/factory");
+const processAuthorizeAccount_1 = require("./start/processAuthorizeAccount");
+const processAuthorizeCreditCard_1 = require("./start/processAuthorizeCreditCard");
+const processAuthorizeMovieTicket_1 = require("./start/processAuthorizeMovieTicket");
+/**
+ * 取引開始
+ */
+function start(params, options) {
+    return async (repos, settings) => {
+        // 金額をfix
+        const amount = params.object.paymentMethod?.amount;
+        if (typeof amount !== 'number') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod.amount');
+        }
+        const transactionNumber = params.transactionNumber;
+        if (typeof transactionNumber !== 'string' || transactionNumber.length === 0) {
+            throw new factory.errors.ArgumentNull('transactionNumber');
+        }
+        await (0, validateSeller_1.validateSeller)(params)(repos);
+        // リソースの対応決済方法検証(2025-12-02~)
+        await (0, validateAcceptedPaymentMethodIfNeeded_1.validateAcceptedPaymentMethodIfNeeded)(params)(repos);
+        // 決済サービス確認
+        const paymentServiceType = params.object?.typeOf;
+        const paymentService = await fixPaymentService(params)(repos);
+        const informActions = await (0, fixInformAction_1.fixInformAction)({
+            paymentService,
+            project: { id: params.project.id }
+        })(repos);
+        // 取引開始
+        let transaction;
+        const startParams = (0, factory_1.createStartParams)({
+            ...params,
+            transactionNumber,
+            paymentServiceType,
+            amount,
+            paymentService,
+            informActions
+        }, { checkedAction: options.checkedAction } // 連携(2024-12-13~)
+        );
+        transaction = await repos.assetTransaction.start(startParams);
+        switch (paymentServiceType) {
+            case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                // 対面決済は特に何もしない
+                break;
+            case factory.service.paymentService.PaymentServiceType.PaymentCard:
+                transaction = await (0, processAuthorizeAccount_1.processAuthorizeAccount)(params, transaction, String(paymentService?.id))(repos);
+                break;
+            case factory.service.paymentService.PaymentServiceType.CreditCard:
+                // transaction =
+                await (0, processAuthorizeCreditCard_1.processAuthorizeCreditCard)(params, transaction, String(paymentService?.id), {
+                    executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {}, // タスク関連付け(2024-05-18~)
+                    ...(options.pendingPaymentAgencyTransaction !== undefined)
+                        ? { pendingPaymentAgencyTransaction: options.pendingPaymentAgencyTransaction }
+                        : undefined
+                })(repos, settings);
+                break;
+            case factory.service.paymentService.PaymentServiceType.MovieTicket:
+                transaction = await (0, processAuthorizeMovieTicket_1.processAuthorizeMovieTicket)(params, transaction, String(paymentService?.id), 
+                // options.useCheckByIdentifierIfNotYet,
+                {
+                    executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {},
+                    purpose: options.purpose,
+                    checkedAction: options.checkedAction
+                })(repos, settings);
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
+        }
+        return transaction;
+    };
+}
+function getPaymentServiceId(params) {
+    let paymentServiceId = '';
+    const paymentServiceType = params.object?.typeOf;
+    if (typeof params.object.id === 'string' && params.object.id.length > 0) {
+        paymentServiceId = params.object.id;
+    }
+    else {
+        switch (paymentServiceType) {
+            case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                // 対面決済は特に何もしない
+                break;
+            case factory.service.paymentService.PaymentServiceType.PaymentCard:
+            case factory.service.paymentService.PaymentServiceType.CreditCard:
+            case factory.service.paymentService.PaymentServiceType.MovieTicket:
+                // リクエストでの指定を必須化(2022-04-12~)
+                throw new factory.errors.ArgumentNull('object.id');
+            default:
+                throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
+        }
+    }
+    return paymentServiceId;
+}
+function fixPaymentService(params) {
+    return async (repos) => {
+        const paymentServiceType = params.object?.typeOf;
+        let paymentService;
+        switch (paymentServiceType) {
+            case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                // no op
+                // FaceToFaceの場合プロダクトは存在しない
+                break;
+            // PaymentCardの場合、プロダクト検索
+            case factory.service.paymentService.PaymentServiceType.PaymentCard:
+                paymentService = (await repos.product.projectFields({
+                    limit: 1,
+                    page: 1,
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: { $eq: factory.product.ProductType.PaymentCard },
+                    id: { $eq: getPaymentServiceId(params) }
+                }, ['availableChannel', 'serviceOutput', 'serviceType', 'potentialAction']
+                // []
+                )).shift();
+                if (paymentService === undefined) {
+                    throw new factory.errors.NotFound('PaymentService');
+                }
+                break;
+            default:
+                paymentService = (await repos.paymentService.projectFields({
+                    limit: 1,
+                    page: 1,
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: { $eq: paymentServiceType },
+                    id: { $eq: getPaymentServiceId(params) }
+                }, ['availableChannel', 'serviceOutput', 'serviceType', 'potentialAction'])).shift();
+                if (paymentService === undefined) {
+                    throw new factory.errors.NotFound('PaymentService');
+                }
+        }
+        return paymentService;
+    };
+}

package/lib/chevre/service/assetTransaction/pay.d.ts

@@ -1,173 +1,11 @@
 /**
  * 決済取引サービス
  */
-import * as GMO from '@motionpicture/gmo-service';
-import * as factory from '../../factory';
-import { Settings } from '../../settings';
-import type { AcceptedOfferRepo } from '../../repo/acceptedOffer';
-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 { CredentialsRepo } from '../../repo/credentials';
-import type { EventRepo } from '../../repo/event';
-import type { EventSeriesRepo } from '../../repo/eventSeries';
-import type { OrderRepo } from '../../repo/order';
-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 { SellerPaymentAcceptedRepo } from '../../repo/sellerPaymentAccepted';
-import type { TaskRepo } from '../../repo/task';
-import * as CreditCardPayment from '../payment/creditCard';
-import * as MovieTicketPayment from '../payment/movieTicket';
-export interface IStartOperationRepos {
-    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
-    accountingReport: AccountingReportRepo;
-    action: ActionRepo;
-    credentials: CredentialsRepo;
-    event: EventRepo;
-    eventSeries: EventSeriesRepo;
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-    potentialAction: PotentialActionRepo;
-    product: ProductRepo;
-    assetTransaction: AssetTransactionRepo;
-    task: TaskRepo;
-}
-export type IStartOperation<T> = (repos: IStartOperationRepos, settings: Settings) => Promise<T>;
-export interface ICancelRepos {
-    assetTransaction: AssetTransactionRepo;
-}
-export type ICancelOperation<T> = (repos: ICancelRepos) => Promise<T>;
-export interface IConfirmRepos {
-    acceptedOffer: AcceptedOfferRepo;
-    action: ActionRepo;
-    accountingReport: AccountingReportRepo;
-    assetTransaction: AssetTransactionRepo;
-    event: EventRepo;
-    order: OrderRepo;
-    task: TaskRepo;
-}
-export type IConfirmOperation<T> = (repos: IConfirmRepos) => Promise<T>;
-export type IExportTasksOperation<T> = (repos: {
-    task: TaskRepo;
-    assetTransaction: AssetTransactionRepo;
-}) => Promise<T>;
-export type ICheckOperation<T> = (repos: {
-    action: ActionRepo;
-    credentials: CredentialsRepo;
-    event: EventRepo;
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-}, settings: Settings) => Promise<T>;
-export type IPublishPaymentUrlOperation<T> = (repos: {
-    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
-    action: ActionRepo;
-    event: EventRepo;
-    eventSeries: EventSeriesRepo;
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-}, settings: Settings) => Promise<T>;
-export type IPublishPaymentUrlResult = CreditCardPayment.IPaymentAgencyTransaction & {
-    paymentMethodId: string;
-    paymentUrl: string;
-};
-/**
- * 決済ロケーション発行
- */
-export declare function publishPaymentUrl(params: Pick<factory.assetTransaction.pay.IStartParamsWithoutDetail, 'agent' | 'location' | 'project' | 'recipient' | 'transactionNumber' | 'typeOf'> & {
-    object: factory.action.accept.pay.IPayObject;
-    /**
-     * add identifier for an unique index(2025-02-25~)
-     */
-    identifier?: string;
-    instrument: factory.action.accept.pay.IInstrument[];
-}, options: {
-    purposeAsTransaction: {
-        id: string;
-    };
-    /**
-     * 実行者
-     */
-    executor?: {
-        /**
-         * task ID
-         * taskによって実行されている場合値が存在する
-         */
-        id?: string;
-    };
-}): IPublishPaymentUrlOperation<IPublishPaymentUrlResult>;
-/**
- * 決済方法認証
- */
-export declare function check(params: factory.action.check.paymentMethod.movieTicket.IAttributes): ICheckOperation<{
-    result: MovieTicketPayment.ICheckResult;
-}>;
-export import IPaymentAgencyTransaction = CreditCardPayment.IPaymentAgencyTransaction;
-/**
- * 取引開始
- */
-export declare function start(params: factory.assetTransaction.pay.IStartParamsWithoutDetail & {
-    instrument: factory.action.trade.pay.IPlaceOrderRelatedInstrument[];
-}, options: {
-    pendingPaymentAgencyTransaction?: CreditCardPayment.IPaymentAgencyTransaction;
-    /**
-     * 実行者
-     */
-    executor?: {
-        /**
-         * task ID
-         * taskによって実行されている場合値が存在する
-         */
-        id?: string;
-    };
-    purpose: {
-        /**
-         * placeOrder ID
-         */
-        id?: string;
-    };
-    checkedAction: {
-        id: string;
-    };
-}): IStartOperation<Pick<factory.assetTransaction.pay.ITransaction, 'id' | 'object'>>;
-/**
- * 取引確定
- */
-export declare function confirm(params: factory.assetTransaction.pay.IConfirmParams & {
-    options: {};
-}): IConfirmOperation<void>;
-/**
- * 取引中止
- */
-export declare function cancel(params: {
-    id?: string;
-    transactionNumber?: string;
-}): ICancelOperation<void>;
-/**
- * 取引のタスク出力
- */
-export declare function exportTasksById(params: {
-    id: string;
-    /**
-     * タスク実行日時バッファ
-     */
-    runsTasksAfterInSeconds?: number;
-}): IExportTasksOperation<{
-    id: string;
-}[]>;
-/**
- * 決済代行取引参照
- */
-export declare function searchGMOTrade(params: {
-    transactionNumber: string;
-}): (repos: {
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-    assetTransaction: AssetTransactionRepo;
-}, settings: Settings) => Promise<GMO.factory.credit.ISearchTradeResult>;
+import { cancel } from './pay/cancel';
+import { check } from './pay/check';
+import { confirm } from './pay/confirm';
+import { exportTasksById } from './pay/exportTasksById';
+import { IPublishPaymentUrlResult, publishPaymentUrl } from './pay/publishPaymentUrl';
+import { searchGMOTrade } from './pay/searchGMOTrade';
+import { IPaymentAgencyTransaction, start } from './pay/start';
+export { IPaymentAgencyTransaction, IPublishPaymentUrlResult, cancel, check, confirm, exportTasksById, publishPaymentUrl, searchGMOTrade, start };