@chevre/domain 24.0.0-alpha.6 → 24.0.0-alpha.61

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

@@ -0,0 +1,66 @@
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { AuthorizationRepo } from '../../../repo/authorization';
+import type { EventRepo } from '../../../repo/event';
+import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import type { IssuerRepo } from '../../../repo/issuer';
+import type { OrderNumberRepo } from '../../../repo/orderNumber';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { ProjectRepo } from '../../../repo/project';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TicketRepo } from '../../../repo/ticket';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import type { TransactionNumberRepo } from '../../../repo/transactionNumber';
+import * as PayTransactionService from '../../assetTransaction/pay';
+interface IPublishPaymentUrlRepos {
+    acceptPayAction: AcceptPayActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    authorization: AuthorizationRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    issuer: IssuerRepo;
+    orderNumber: OrderNumberRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    project: ProjectRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+type IPublishPaymentUrlOperation<T> = (repos: IPublishPaymentUrlRepos, settings: Settings) => Promise<T>;
+type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail & {
+    ticketToken?: string;
+};
+/**
+ * 外部決済ロケーションを発行する
+ */
+declare function publishPaymentUrl(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: Pick<IObjectWithoutDetail, 'amount' | 'creditCard' | 'issuedThrough' | 'method' | 'paymentMethod' | 'referencesOrder'>;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+    location: factory.action.trade.pay.ILocation;
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+    /**
+     * add identifier for an unique index(2025-02-25~)
+     */
+    identifier?: string;
+    instrument: factory.action.trade.pay.IAcceptedPaymentMethodOfferAsInstrument[];
+}): IPublishPaymentUrlOperation<Pick<PayTransactionService.IPublishPaymentUrlResult, 'paymentMethodId' | 'paymentUrl'>>;
+export { IPublishPaymentUrlRepos, publishPaymentUrl };

package/lib/chevre/service/payment/any/publishPaymentUrl.js

@@ -0,0 +1,133 @@
+"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.publishPaymentUrl = publishPaymentUrl;
+const factory = __importStar(require("../../../factory"));
+// import type { TransactionProcessRepo } from '../../repo/transactionProcess';
+const PayTransactionService = __importStar(require("../../assetTransaction/pay"));
+const issueOrderNumberIfNotExist_1 = require("../../transaction/placeOrder/issueOrderNumberIfNotExist");
+const fixTransactionNumberOnPublishPaymentUrl_1 = require("./publishPaymentUrl/fixTransactionNumberOnPublishPaymentUrl");
+const factory_1 = require("./factory");
+/**
+ * 外部決済ロケーションを発行する
+ */
+function publishPaymentUrl(params) {
+    return async (repos, settings) => {
+        const { paymentServiceType, purpose, project } = params;
+        if (purpose.typeOf !== factory.transactionType.PlaceOrder) {
+            throw new factory.errors.NotImplemented(`purpose.typeOf '${purpose.typeOf} not implemented'`);
+        }
+        try {
+            const transaction = await repos.placeOrder.findPlaceOrderInProgressById({ typeOf: purpose.typeOf, id: purpose.id }, ['expires', 'seller', 'project']);
+            if (project.id !== transaction.project.id) {
+                throw new factory.errors.NotFound(factory.transactionType.PlaceOrder);
+            }
+            // issueOrderNumber(2025-03-11~)
+            await (0, issueOrderNumberIfNotExist_1.issueOrderNumberIfNotExist)({
+                project: { id: transaction.project.id },
+                id: transaction.id,
+                object: { orderDate: new Date() }
+            })(repos);
+            // 取引番号生成
+            const { transactionNumber, ticketToken } = await (0, fixTransactionNumberOnPublishPaymentUrl_1.fixTransactionNumberOnPublishPaymentUrl)({
+                object: params.object,
+                transaction,
+                paymentServiceType
+            })(repos);
+            // let transactionNumber: string | undefined;
+            // // support ticketToken(2024-08-21~)
+            // const { permitOrInvoice } =
+            //     await verifyTicketTokenAsNeeded({ project, object: params.object, paymentServiceType, purpose })(repos);
+            // if (permitOrInvoice?.typeOf === factory.permit.PermitType.Permit) {
+            //     const paymentMethodIdByPermit = permitOrInvoice?.identifier;
+            //     if (typeof paymentMethodIdByPermit === 'string') {
+            //         transactionNumber = paymentMethodIdByPermit;
+            //     }
+            // }
+            // if (typeof transactionNumber !== 'string') {
+            //     const publishTransactionNumberResult = await repos.transactionNumber.publishByTimestamp({ startDate: new Date() });
+            //     transactionNumber = publishTransactionNumberResult.transactionNumber;
+            // }
+            // URL発行
+            const authorizeObject = {
+                ...params.object,
+                accountId: '',
+                paymentMethodId: transactionNumber,
+                typeOf: factory.action.authorize.paymentMethod.any.ResultType.Payment,
+                // support referencesOrder(2025-11-24~)
+                referencesOrder: (params.object.referencesOrder?.typeOf === factory.order.OrderType.Order)
+                    ? params.object.referencesOrder
+                    : { typeOf: factory.order.OrderType.Order }
+            };
+            const startParams = (0, factory_1.creatPublishPaymentUrlParams)({
+                object: authorizeObject,
+                paymentServiceType,
+                transaction: transaction,
+                transactionNumber: transactionNumber,
+                location: params.location,
+                instrument: params.instrument,
+                ...(typeof params.identifier === 'string') ? { identifier: params.identifier } : undefined,
+                ...(typeof ticketToken === 'string') ? { ticketToken } : undefined
+            });
+            const taskId = params.sameAs?.id;
+            const result = await PayTransactionService.publishPaymentUrl(startParams, {
+                purposeAsTransaction: { id: transaction.id },
+                executor: (typeof taskId === 'string') ? { id: taskId } : {} // タスク関連付け(2024-05-22~)
+            })(repos, settings);
+            // 取引に保管
+            const paymentMethodByPaymentUrl = {
+                // typeOf: params.object.paymentMethod, // discontinue(2024-06-05~)
+                paymentMethodId: result.paymentMethodId
+                // paymentUrl: result.paymentUrl, // migrate to recipe(2024-06-05~)
+                // issuedThrough: {
+                //     id: (typeof startParams.object.id === 'string') ? startParams.object.id : ''
+                // } // migrate to acceptAction(2024-06-05~)
+                // GMO IFを保管(2024-01-01~)
+                // entryTranArgs: result.entryTranArgs, // migrate to recipe(2024-06-05~)
+                // entryTranResult: result.entryTranResult, // migrate to recipe(2024-06-05~)
+                // execTranArgs: result.execTranArgs, // migrate to recipe(2024-06-05~)
+                // execTranResult: result.execTranResult, // migrate to recipe(2024-06-05~)
+                // paymentMethod: startParams.object.paymentMethod // 拡張(2024-01-04~) // migrate to acceptAction(2024-06-05~)
+            };
+            await repos.placeOrder.findByIdAndUpdateInProgress({
+                id: transaction.id,
+                update: { $set: { 'object.paymentMethods': paymentMethodByPaymentUrl } }
+            });
+            return {
+                paymentMethodId: result.paymentMethodId,
+                paymentUrl: result.paymentUrl
+            };
+        }
+        catch (error) {
+            // 複数対応(2024-03-27~)
+            if (Array.isArray(error)) {
+                throw error[0];
+            }
+            else {
+                throw error;
+            }
+        }
+    };
+}

package/lib/chevre/service/payment/any/verifyTicketTokenAsNeeded.js

@@ -35,7 +35,7 @@ function verifyTicketTokenAsNeeded(params) {
             switch (paymentServiceType) {
                 case factory.service.paymentService.PaymentServiceType.CreditCard:
                 case factory.service.paymentService.PaymentServiceType.MovieTicket:
-                case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                case factory.service.paymentService.PaymentServiceType.FaceToFace: {
                     const ticket = (await repos.ticket.findTickets({
                         limit: 1,
                         page: 1,
@@ -88,6 +88,7 @@ function verifyTicketTokenAsNeeded(params) {
                         throw new factory.errors.Argument('ticketToken', 'must be OwnershipInfo');
                     }
                     break;
+                }
                 default:
                     // no op
                     throw new factory.errors.NotImplemented(`ticketToken issued through ${paymentServiceType} not implemented`);

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

@@ -0,0 +1,34 @@
+import * as factory from '../../../factory';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
+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 type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+/**
+ * 決済承認中止
+ * タスクから決済承認を取り消す
+ */
+declare function voidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    project: {
+        id: string;
+    };
+    sameAs?: {
+        id: string;
+    };
+}): (repos: {
+    accountingReport: AccountingReportRepo;
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}) => Promise<void>;
+export { voidPayTransaction, };

package/lib/chevre/service/payment/any/voidPayTransaction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voidPayTransaction = voidPayTransaction;
+const invalidatePaymentUrl_1 = require("./invalidatePaymentUrl");
+const processVoidPayTransaction_1 = require("./processVoidPayTransaction");
+/**
+ * 決済承認中止
+ * タスクから決済承認を取り消す
+ */
+function voidPayTransaction(params) {
+    return async (repos
+    // settings: Settings
+    ) => {
+        // 決済承認アクション確認不要(2024-03-12~)
+        // 決済承認アクションを検索
+        // let authorizeActions = <factory.action.authorize.paymentMethod.any.IAction[]>
+        //     await repos.action.searchByPurpose({
+        //         typeOf: factory.actionType.AuthorizeAction,
+        //         purpose: {
+        //             typeOf: params.purpose.typeOf,
+        //             id: params.purpose.id
+        //         }
+        //     });
+        // authorizeActions = authorizeActions.filter(
+        //     (a) => a.object.typeOf === factory.action.authorize.paymentMethod.any.ResultType.Payment
+        // );
+        // // Chevreを使用した承認を取り消し
+        // const authorizeActionsWithChevre = authorizeActions.filter((a) => {
+        //     return a.instrument?.identifier === factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre;
+        // });
+        // if (authorizeActionsWithChevre.length > 0) {
+        //     await processVoidPayTransaction(params)(repos);
+        // }
+        await (0, processVoidPayTransaction_1.processVoidPayTransaction)(params)(repos);
+        // 決済URL無効化もここで処理
+        await (0, invalidatePaymentUrl_1.invalidatePaymentUrl)(params)(repos);
+    };
+}

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

@@ -1,306 +1,9 @@
-import * as factory from '../../factory';
-import { Settings } from '../../settings';
-import type { AcceptedPaymentMethodRepo } from '../../repo/acceptedPaymentMethod';
-import type { AccountingReportRepo } from '../../repo/accountingReport';
-import type { ActionRepo, IMinimizedPurchaseNumberAuthResult } 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 { TransactionRepo } from '../../repo/transaction';
-import type { TransactionNumberRepo } from '../../repo/transactionNumber';
-import * as PayTransactionService from '../assetTransaction/pay';
 import { onPaymentStatusChanged } from './any/onPaymentStatusChanged';
-import { person2username } from './any/person2username';
-/**
- * 決済承認中止
- * タスクから決済承認を取り消す
- */
-declare function voidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
-    project: {
-        id: string;
-    };
-    sameAs?: {
-        id: string;
-    };
-}): (repos: {
-    accountingReport: AccountingReportRepo;
-    action: ActionRepo;
-    assetTransaction: AssetTransactionRepo;
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-    task: TaskRepo;
-    transaction: TransactionRepo;
-}) => Promise<void>;
-declare function invalidatePaymentUrl(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
-    sameAs?: {
-        id: string;
-    };
-}): (repos: {
-    accountingReport: AccountingReportRepo;
-    action: ActionRepo;
-    assetTransaction: AssetTransactionRepo;
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-    task: TaskRepo;
-    transaction: TransactionRepo;
-}) => Promise<void>;
-/**
- * 決済承認中止
- * apiもしくはタスクから決済承認を取り消す
- */
-declare function processVoidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
-    project: {
-        id: string;
-    };
-    sameAs?: {
-        /**
-         * 実行元タスクID
-         */
-        id: string;
-    };
-}): (repos: {
-    action: ActionRepo;
-    accountingReport: AccountingReportRepo;
-    assetTransaction: AssetTransactionRepo;
-    task: TaskRepo;
-    transaction: TransactionRepo;
-}) => Promise<void>;
-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;
-    transaction: TransactionRepo;
-    transactionNumber: TransactionNumberRepo;
-}
-type IAuthorizeOperation<T> = (repos: IAuthorizeRepos, settings: Settings) => Promise<T>;
-interface IPublishPaymentUrlRepos {
-    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
-    action: ActionRepo;
-    assetTransaction: AssetTransactionRepo;
-    authorization: AuthorizationRepo;
-    event: EventRepo;
-    eventSeries: EventSeriesRepo;
-    orderNumber: OrderNumberRepo;
-    paymentAccepted: SellerPaymentAcceptedRepo;
-    paymentService: PaymentServiceRepo;
-    paymentServiceProvider: PaymentServiceProviderRepo;
-    project: ProjectRepo;
-    ticket: TicketRepo;
-    transaction: TransactionRepo;
-    transactionNumber: TransactionNumberRepo;
-}
-type IPublishPaymentUrlOperation<T> = (repos: IPublishPaymentUrlRepos, settings: Settings) => Promise<T>;
-type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail & {
-    ticketToken?: string;
-};
-/**
- * 外部決済ロケーションを発行する
- */
-declare function publishPaymentUrl(params: {
-    project: {
-        id: string;
-    };
-    agent: {
-        id: string;
-    };
-    object: Pick<IObjectWithoutDetail, 'amount' | 'creditCard' | 'issuedThrough' | 'method' | 'paymentMethod' | 'referencesOrder'>;
-    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
-    paymentServiceType: factory.service.paymentService.PaymentServiceType;
-    location: factory.action.trade.pay.ILocation;
-    sameAs?: {
-        /**
-         * 実行元タスクID
-         */
-        id: string;
-    };
-    /**
-     * add identifier for an unique index(2025-02-25~)
-     */
-    identifier?: string;
-    instrument: factory.action.trade.pay.IAcceptedPaymentMethodOfferAsInstrument[];
-}): IPublishPaymentUrlOperation<Pick<PayTransactionService.IPublishPaymentUrlResult, 'paymentMethodId' | 'paymentUrl'>>;
-/**
- * 決済承認
- */
-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;
-}>;
-interface IFindAuthorizeActionResult {
-    /**
-     * アクションID
-     */
-    id?: string;
-    /**
-     * アクションスタータス
-     */
-    actionStatus: factory.actionStatusType;
-    /**
-     * エラー
-     */
-    error?: {
-        name?: string;
-        message?: string;
-    };
-}
-interface IFindCheckActionResult {
-    /**
-     * アクションID
-     */
-    id?: string;
-    /**
-     * アクションスタータス
-     */
-    actionStatus: factory.actionStatusType;
-    /**
-     * エラー
-     */
-    error?: {
-        name?: string;
-        message?: string;
-    };
-    result?: {
-        purchaseNumberAuthResult: IMinimizedPurchaseNumberAuthResult;
-    };
-}
-interface IFindAcceptActionResult {
-    /**
-     * アクションID
-     */
-    id?: string;
-    /**
-     * アクションスタータス
-     */
-    actionStatus: factory.actionStatusType;
-    object?: Pick<factory.action.accept.pay.IObject, 'transactionNumber'>;
-    /**
-     * エラー
-     */
-    error?: {
-        name?: string;
-        message?: string;
-    };
-    result?: factory.action.accept.pay.IResult;
-}
-declare function findAuthorizeAction(params: {
-    project: {
-        id: string;
-    };
-    sameAs: {
-        /**
-         * task ID
-         */
-        id: string;
-    };
-    purpose: {
-        /**
-         * transaction ID
-         */
-        id: string;
-    };
-}): (repos: {
-    action: ActionRepo;
-    task: TaskRepo;
-}) => Promise<IFindAuthorizeActionResult>;
-declare function findCheckAction(params: {
-    project: {
-        id: string;
-    };
-    sameAs: {
-        /**
-         * task ID
-         */
-        id: string;
-    };
-    purpose: {
-        /**
-         * transaction ID
-         */
-        id: string;
-    };
-}): (repos: {
-    action: ActionRepo;
-    task: TaskRepo;
-}) => Promise<IFindCheckActionResult>;
-declare function findAcceptAction(params: {
-    project: {
-        id: string;
-    };
-    sameAs: {
-        /**
-         * task ID
-         */
-        id: string;
-    };
-    purpose: {
-        /**
-         * transaction ID
-         */
-        id: string;
-    };
-}): (repos: {
-    action: ActionRepo;
-    task: TaskRepo;
-}) => Promise<IFindAcceptActionResult>;
-export { onPaymentStatusChanged, authorize, findAcceptAction, findAuthorizeAction, findCheckAction, invalidatePaymentUrl, voidPayTransaction, person2username, processVoidPayTransaction, publishPaymentUrl };
+import { authorize } from './any/authorize';
+import { findAcceptAction } from './any/findAcceptAction';
+import { findAuthorizeAction } from './any/findAuthorizeAction';
+import { findCheckAction } from './any/findCheckAction';
+import { voidPayTransaction } from './any/voidPayTransaction';
+import { processVoidPayTransaction } from './any/processVoidPayTransaction';
+import { publishPaymentUrl } from './any/publishPaymentUrl';
+export { onPaymentStatusChanged, authorize, findAcceptAction, findAuthorizeAction, findCheckAction, voidPayTransaction, processVoidPayTransaction, publishPaymentUrl };