@houlak/plexo-sdk 0.1.7-fx → 0.1.8-fx

package/lib/handler/PlexoHandler.d.ts

@@ -2,7 +2,7 @@ import { Authorization, AuthorizationInfo, BaseServerResponse, CancelRequest, Cl
 import { BaseResponse } from './types/BaseResponse';
 import { FixedCustomData } from '../sdk/models/FixedCustomData';
 export declare const PlexoHandler: {
-    AddCommerce: (commerceRequest: CommerceRequest) => Promise<BaseResponse<Commerce>>;
+    AddCommerce: (commerceRequest: CommerceRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Commerce>>;
     AddIssuerCommerce: (issuerData: IssuerData) => Promise<BaseResponse<IssuerData>>;
     DeleteCommerce: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
     DeleteInstrument: (instrument: DeleteInstrumentRequest) => Promise<BaseResponse<BaseServerResponse>>;
@@ -19,7 +19,7 @@ export declare const PlexoHandler: {
     CodeAction: (request: CodeRequest) => Promise<BaseResponse<Transaction>>;
     StartReserve: (payment: ReserveRequest) => Promise<BaseResponse<Transaction>>;
     Status: (payment: Reference) => Promise<BaseResponse<Transaction>>;
-    ExpressCheckout: (expressCheckout: ExpressCheckoutRequest) => Promise<BaseResponse<Session>>;
+    ExpressCheckout: (expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Session>>;
     ObtainCsvTransactions: (query: TransactionQuery) => Promise<BaseResponse<TransactionsCSV>>;
     ObtainTransactions: (query: TransactionQuery) => Promise<BaseResponse<TransactionCursor>>;
     Purchase: (purchase: PaymentRequest) => Promise<BaseResponse<Transaction>>;

package/lib/handler/PlexoHandler.js

@@ -52,11 +52,11 @@ var index_1 = require("../sdk/index");
 var evaluator_service_1 = require("./services/evaluator.service");
 var utils_1 = require("../utils");
 var paymentGatewayClient = new index_1.PaymentGatewayClient();
-var AddCommerce = function (commerceRequest) { return __awaiter(void 0, void 0, void 0, function () {
+var AddCommerce = function (commerceRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var commerceResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.AddCommerceAsync(commerceRequest)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.AddCommerceAsync(commerceRequest, fixedCustomData)];
             case 1:
                 commerceResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceRequest, commerceResponse)];
@@ -256,11 +256,11 @@ var Status = function (payment) { return __awaiter(void 0, void 0, void 0, funct
         }
     });
 }); };
-var ExpressCheckout = function (expressCheckout) { return __awaiter(void 0, void 0, void 0, function () {
+var ExpressCheckout = function (expressCheckout, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var expressCheckoutResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.ExpressCheckoutAsync(expressCheckout)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.ExpressCheckoutAsync(expressCheckout, fixedCustomData)];
             case 1:
                 expressCheckoutResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(expressCheckout, expressCheckoutResponse)];

package/lib/sdk/IPaymentGatewayClient.d.ts

@@ -2,7 +2,7 @@ import { IssuerProcessor } from '.';
 import { FixedCustomData } from './models/FixedCustomData';
 import { Authorization, AuthorizationInfo, CancelRequest, ClientSignedResponse, CodeRequest, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceModifyRequest, CommerceRequest, CreateBankInstrumentRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, PaymentRequest, PaymentInstrument, Reference, Reserve, ReserveRequest, BaseServerResponse, ServerResponse, ServerSignedCallback, Session, Transaction, TransactionCallback, TransactionCursor, TransactionQuery } from './models/IndexSDK';
 export interface IPaymentGatewayClient {
-    AddCommerceAsync(commerce: CommerceRequest): Promise<ServerResponse<Commerce>>;
+    AddCommerceAsync(commerce: CommerceRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce>>;
     AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>>;
     DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
     DeleteInstrumentAsync(info: DeleteInstrumentRequest): Promise<BaseServerResponse>;
@@ -19,7 +19,7 @@ export interface IPaymentGatewayClient {
     CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>>;
     StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>>;
     StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>>;
-    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest): Promise<ServerResponse<Session>>;
+    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
     ObtainCsvTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<string>>;
     ObtainTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<TransactionCursor>>;
     PurchaseAsync(payment: PaymentRequest): Promise<ServerResponse<Transaction>>;

package/lib/sdk/PaymentGatewayClient.d.ts

@@ -3,11 +3,10 @@ import { IssuerProcessor } from './index';
 import { IPaymentGatewayClient } from './IPaymentGatewayClient';
 import { FixedCustomData } from './models/FixedCustomData';
 export declare class PaymentGatewayClient implements IPaymentGatewayClient {
-    AddCommerceAsync(commerce: CommerceRequest): Promise<ServerResponse<Commerce>>;
     AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>>;
-    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<ServerResponse<BaseServerResponse>>;
-    DeleteInstrumentAsync(info: DeleteInstrumentRequest): Promise<ServerResponse<BaseServerResponse>>;
-    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest): Promise<ServerResponse<BaseServerResponse>>;
+    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
+    DeleteInstrumentAsync(info: DeleteInstrumentRequest): Promise<BaseServerResponse>;
+    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest): Promise<BaseServerResponse>;
     GetCommerceIssuersAsync(commerceIdRequest: CommerceIdRequest): Promise<ServerResponse<IssuerData[]>>;
     GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>>;
     GetSupportedIssuersAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerInfo[]>>;
@@ -20,12 +19,13 @@ export declare class PaymentGatewayClient implements IPaymentGatewayClient {
     CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>>;
     StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>>;
     StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>>;
-    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest): Promise<ServerResponse<Session>>;
     ObtainCsvTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<string>>;
     ObtainTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<TransactionCursor>>;
     PurchaseAsync(payment: PaymentRequest): Promise<ServerResponse<Transaction>>;
     CreateBankInstrumentAsync(request: CreateBankInstrumentRequest): Promise<ServerResponse<PaymentInstrument>>;
     EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>>;
+    AddCommerceAsync(commerce: CommerceRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce>>;
+    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
     UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>, plexoUrl: string): Promise<ServerResponse<InstrumentCallback>>;
     UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>, plexoUrl: string): Promise<ServerResponse<TransactionCallback>>;
     SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>, plexoCertificatePath: string, plexoCertificatePassword: string): Promise<ClientSignedResponse>;

package/lib/sdk/PaymentGatewayClient.js

@@ -55,14 +55,14 @@ var utils_1 = require("../utils");
 var client = axios_1.default.create({
     baseURL: "https://testing.plexo.com.uy:4043/SecurePaymentGateway.svc",
 });
-var requestToPlexo = function (endpoint, request, plexoClientName, plexoCertificatePassword, plexoCertificatePath) { return __awaiter(void 0, void 0, void 0, function () {
+var requestToPlexo = function (endpoint, request, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var object, stateObject, signedClientRequest, data, err_1;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 _a.trys.push([0, 3, , 4]);
                 object = {
-                    client: plexoClientName,
+                    client: fixedCustomData.plexoClientName,
                     request: request,
                 };
                 stateObject = {
@@ -70,7 +70,7 @@ var requestToPlexo = function (endpoint, request, plexoClientName, plexoCertific
                     utcUnixTimeExpiration: Date.parse(new Date().toString()),
                     object: object,
                 };
-                return [4 /*yield*/, signatureHelper_1.SignatureHelper.signRequest(stateObject, plexoCertificatePassword, plexoCertificatePath)];
+                return [4 /*yield*/, signatureHelper_1.SignatureHelper.signRequest(stateObject, fixedCustomData.plexoCertificatePassword, fixedCustomData.plexoCertificatePath)];
             case 1:
                 signedClientRequest = _a.sent();
                 logger_lib_1.default.debug("URL PX: ".concat(endpoint));
@@ -91,236 +91,317 @@ var requestToPlexo = function (endpoint, request, plexoClientName, plexoCertific
 var PaymentGatewayClient = /** @class */ (function () {
     function PaymentGatewayClient() {
     }
-    PaymentGatewayClient.prototype.AddCommerceAsync = function (commerce) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Add', commerce, commerce.plexoClientName, commerce.plexoCertificatePassword, commerce.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
     PaymentGatewayClient.prototype.AddIssuerCommerceAsync = function (issuerData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer/Add', issuerData, issuerData.plexoClientName, issuerData.plexoCertificatePassword, issuerData.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.DeleteCommerceAsync = function (commerceIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Delete', commerceIdRequest, commerceIdRequest.plexoClientName, commerceIdRequest.plexoCertificatePassword, commerceIdRequest.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.DeleteInstrumentAsync = function (info) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Instruments/Delete', info, info.plexoClientName, info.plexoCertificatePassword, info.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.DeleteIssuerCommerceAsync = function (commerceIssuerIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer/Delete', commerceIssuerIdRequest, commerceIssuerIdRequest.plexoClientName, commerceIssuerIdRequest.plexoCertificatePassword, commerceIssuerIdRequest.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetCommerceIssuersAsync = function (commerceIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer', commerceIdRequest, commerceIdRequest.plexoClientName, commerceIdRequest.plexoCertificatePassword, commerceIdRequest.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetCommercesAsync = function (fixedCustomData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce', '', fixedCustomData.plexoClientName, fixedCustomData.plexoCertificatePassword, fixedCustomData.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetSupportedIssuersAsync = function (fixedCustomData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Issuer', '', fixedCustomData.plexoClientName, fixedCustomData.plexoCertificatePassword, fixedCustomData.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetSupportedPaymentProcessorsAsync = function (fixedCustomData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/PaymentProcessors', '', fixedCustomData.plexoClientName, fixedCustomData.plexoCertificatePassword, fixedCustomData.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.ModifyCommerceAsync = function (commerceModifyRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Modify', commerceModifyRequest, commerceModifyRequest.plexoClientName, commerceModifyRequest.plexoCertificatePassword, commerceModifyRequest.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetInstrumentsAsync = function (authorizationInfo) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Instruments', authorizationInfo, authorizationInfo.plexoClientName, authorizationInfo.plexoCertificatePassword, authorizationInfo.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.SetDefaultCommerceAsync = function (commerceIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/SetDefault', commerceIdRequest, commerceIdRequest.plexoClientName, commerceIdRequest.plexoCertificatePassword, commerceIdRequest.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.AuthorizeAsync = function (authorization) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Auth', authorization, authorization.plexoClientName, authorization.plexoCertificatePassword, authorization.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.CancelAsync = function (cancel) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/Cancel', cancel, cancel.plexoClientName, cancel.plexoCertificatePassword, cancel.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.CodeActionAsync = function (request) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Code', request, request.plexoClientName, request.plexoCertificatePassword, request.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.StartReserveAsync = function (payment) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/StartReserve', payment, payment.plexoClientName, payment.plexoCertificatePassword, payment.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.StatusAsync = function (payment) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/Status', payment, payment.plexoClientName, payment.plexoCertificatePassword, payment.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    PaymentGatewayClient.prototype.ExpressCheckoutAsync = function (expressCheckout) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', expressCheckout, expressCheckout.authorizationData.plexoClientName, expressCheckout.authorizationData.plexoCertificatePassword, expressCheckout.authorizationData.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.ObtainCsvTransactionsAsync = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', query, query.plexoClientName, query.plexoCertificatePassword, query.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.ObtainTransactionsAsync = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Transactions', query, query.plexoClientName, query.plexoCertificatePassword, query.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.PurchaseAsync = function (payment) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/Purchase', payment, payment.plexoClientName, payment.plexoCertificatePassword, payment.plexoCertificatePath)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.CreateBankInstrumentAsync = function (request) {
+        throw new Error('Method not implemented.');
+    };
+    PaymentGatewayClient.prototype.EndReserveAsync = function (reserve) {
+        throw new Error('Method not implemented.');
+    };
+    PaymentGatewayClient.prototype.AddCommerceAsync = function (commerce, fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Instruments/Bank', request, request.plexoClientName, request.plexoCertificatePassword, request.plexoCertificatePath)];
+                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Add', commerce, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.EndReserveAsync = function (reserve) {
+    /*async AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>> {
+      return await requestToPlexo<IssuerData, ServerResponse<IssuerData>>(
+        '/Commerce/Issuer/Add',
+        issuerData,
+        issuerData.plexoClientName,
+        issuerData.plexoCertificatePassword,
+        issuerData.plexoCertificatePath,
+      )
+    }
+  
+    async DeleteCommerceAsync(
+      commerceIdRequest: CommerceIdRequest,
+    ): Promise<ServerResponse<BaseServerResponse>> {
+      return await requestToPlexo<CommerceIdRequest, ServerResponse<BaseServerResponse>>(
+        '/Commerce/Delete',
+        commerceIdRequest,
+        commerceIdRequest.plexoClientName,
+        commerceIdRequest.plexoCertificatePassword,
+        commerceIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async DeleteInstrumentAsync(
+      info: DeleteInstrumentRequest,
+    ): Promise<ServerResponse<BaseServerResponse>> {
+      return await requestToPlexo<DeleteInstrumentRequest, ServerResponse<BaseServerResponse>>(
+        '/Instruments/Delete',
+        info,
+        info.plexoClientName,
+        info.plexoCertificatePassword,
+        info.plexoCertificatePath,
+      )
+    }
+  
+    async DeleteIssuerCommerceAsync(
+      commerceIssuerIdRequest: CommerceIssuerIdRequest,
+    ): Promise<ServerResponse<BaseServerResponse>> {
+      return await requestToPlexo<CommerceIssuerIdRequest, ServerResponse<BaseServerResponse>>(
+        '/Commerce/Issuer/Delete',
+        commerceIssuerIdRequest,
+        commerceIssuerIdRequest.plexoClientName,
+        commerceIssuerIdRequest.plexoCertificatePassword,
+        commerceIssuerIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async GetCommerceIssuersAsync(
+      commerceIdRequest: CommerceIdRequest,
+    ): Promise<ServerResponse<IssuerData[]>> {
+      return await requestToPlexo<CommerceIdRequest, ServerResponse<IssuerData[]>>(
+        '/Commerce/Issuer',
+        commerceIdRequest,
+        commerceIdRequest.plexoClientName,
+        commerceIdRequest.plexoCertificatePassword,
+        commerceIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>> {
+      return await requestToPlexo<string, ServerResponse<Commerce[]>>(
+        '/Commerce',
+        '',
+        fixedCustomData.plexoClientName,
+        fixedCustomData.plexoCertificatePassword,
+        fixedCustomData.plexoCertificatePath,
+      )
+    }
+  
+    async GetSupportedIssuersAsync(
+      fixedCustomData: FixedCustomData,
+    ): Promise<ServerResponse<IssuerInfo[]>> {
+      return await requestToPlexo<string, ServerResponse<IssuerInfo[]>>(
+        '/Issuer',
+        '',
+        fixedCustomData.plexoClientName,
+        fixedCustomData.plexoCertificatePassword,
+        fixedCustomData.plexoCertificatePath,
+      )
+    }
+  
+    async GetSupportedPaymentProcessorsAsync(
+      fixedCustomData: FixedCustomData,
+    ): Promise<ServerResponse<IssuerProcessor[]>> {
+      return await requestToPlexo<string, ServerResponse<IssuerProcessor[]>>(
+        '/PaymentProcessors',
+        '',
+        fixedCustomData.plexoClientName,
+        fixedCustomData.plexoCertificatePassword,
+        fixedCustomData.plexoCertificatePath,
+      )
+    }
+  
+    async ModifyCommerceAsync(
+      commerceModifyRequest: CommerceModifyRequest,
+    ): Promise<ServerResponse<Commerce>> {
+      return await requestToPlexo<CommerceModifyRequest, ServerResponse<Commerce>>(
+        '/Commerce/Modify',
+        commerceModifyRequest,
+        commerceModifyRequest.plexoClientName,
+        commerceModifyRequest.plexoCertificatePassword,
+        commerceModifyRequest.plexoCertificatePath,
+      )
+    }
+  
+    async GetInstrumentsAsync(
+      authorizationInfo: AuthorizationInfo,
+    ): Promise<ServerResponse<PaymentInstrument[]>> {
+      return await requestToPlexo<AuthorizationInfo, ServerResponse<PaymentInstrument[]>>(
+        '/Instruments',
+        authorizationInfo,
+        authorizationInfo.plexoClientName,
+        authorizationInfo.plexoCertificatePassword,
+        authorizationInfo.plexoCertificatePath,
+      )
+    }
+  
+    async SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse> {
+      return await requestToPlexo<CommerceIdRequest, BaseServerResponse>(
+        '/Commerce/SetDefault',
+        commerceIdRequest,
+        commerceIdRequest.plexoClientName,
+        commerceIdRequest.plexoCertificatePassword,
+        commerceIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async AuthorizeAsync(authorization: Authorization): Promise<ServerResponse<Session>> {
+      return await requestToPlexo<Authorization, ServerResponse<Session>>(
+        '/Auth',
+        authorization,
+        authorization.plexoClientName,
+        authorization.plexoCertificatePassword,
+        authorization.plexoCertificatePath,
+      )
+    }
+  
+    async CancelAsync(cancel: CancelRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<CancelRequest, ServerResponse<Transaction>>(
+        '/Operation/Cancel',
+        cancel,
+        cancel.plexoClientName,
+        cancel.plexoCertificatePassword,
+        cancel.plexoCertificatePath,
+      )
+    }
+  
+    async CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<CodeRequest, ServerResponse<Transaction>>(
+        '/Code',
+        request,
+        request.plexoClientName,
+        request.plexoCertificatePassword,
+        request.plexoCertificatePath,
+      )
+    }
+  
+    async StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<ReserveRequest, ServerResponse<Transaction>>(
+        '/Operation/StartReserve',
+        payment,
+        payment.plexoClientName,
+        payment.plexoCertificatePassword,
+        payment.plexoCertificatePath,
+      )
+    }
+  
+    async StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<Reference, ServerResponse<Transaction>>(
+        '/Operation/Status',
+        payment,
+        payment.plexoClientName,
+        payment.plexoCertificatePassword,
+        payment.plexoCertificatePath,
+      )
+    }*/
+    PaymentGatewayClient.prototype.ExpressCheckoutAsync = function (expressCheckout, fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/EndReserve', reserve, reserve.plexoClientName, reserve.plexoCertificatePassword, reserve.plexoCertificatePath)];
+                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', expressCheckout, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
+    /*async ObtainCsvTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<string>> {
+      return await requestToPlexo<TransactionQuery, ServerResponse<string>>(
+        '/ExpressCheckout',
+        query,
+        query.plexoClientName,
+        query.plexoCertificatePassword,
+        query.plexoCertificatePath,
+      )
+    }
+  
+    async ObtainTransactionsAsync(
+      query: TransactionQuery,
+    ): Promise<ServerResponse<TransactionCursor>> {
+      return await requestToPlexo<TransactionQuery, ServerResponse<TransactionCursor>>(
+        '/Transactions',
+        query,
+        query.plexoClientName,
+        query.plexoCertificatePassword,
+        query.plexoCertificatePath,
+      )
+    }
+  
+    async PurchaseAsync(payment: PaymentRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<PaymentRequest, ServerResponse<Transaction>>(
+        '/Operation/Purchase',
+        payment,
+        payment.plexoClientName,
+        payment.plexoCertificatePassword,
+        payment.plexoCertificatePath,
+      )
+    }
+  
+    async CreateBankInstrumentAsync(
+      request: CreateBankInstrumentRequest,
+    ): Promise<ServerResponse<PaymentInstrument>> {
+      return await requestToPlexo<CreateBankInstrumentRequest, ServerResponse<PaymentInstrument>>(
+        '/Instruments/Bank',
+        request,
+        request.plexoClientName,
+        request.plexoCertificatePassword,
+        request.plexoCertificatePath,
+      )
+    }
+  
+    async EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<Reserve, ServerResponse<Transaction>>(
+        '/Operation/EndReserve',
+        reserve,
+        reserve.plexoClientName,
+        reserve.plexoCertificatePassword,
+        reserve.plexoCertificatePath,
+      )
+    }*/
     PaymentGatewayClient.prototype.UnwrapInstrumentCallbackAsync = function (serverSignedInstrumentCallback, plexoUrl) {
         return __awaiter(this, void 0, void 0, function () {
             var verify;

package/lib/sdk/models/CommerceRequest.d.ts

@@ -1,5 +1,4 @@
-import { FixedCustomData } from './FixedCustomData';
-export declare class CommerceRequest extends FixedCustomData {
+export declare class CommerceRequest {
     name: string;
-    constructor(name: string, plexoClientName: string, plexoCertificatePassword: string, plexoCertificatePath: string);
+    constructor(name: string);
 }

package/lib/sdk/models/CommerceRequest.js

@@ -1,29 +1,10 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommerceRequest = void 0;
-var FixedCustomData_1 = require("./FixedCustomData");
-var CommerceRequest = /** @class */ (function (_super) {
-    __extends(CommerceRequest, _super);
-    function CommerceRequest(name, plexoClientName, plexoCertificatePassword, plexoCertificatePath) {
-        var _this = _super.call(this, plexoClientName, plexoCertificatePassword, plexoCertificatePath) || this;
-        _this.name = name;
-        return _this;
+var CommerceRequest = /** @class */ (function () {
+    function CommerceRequest(name) {
+        this.name = name;
     }
     return CommerceRequest;
-}(FixedCustomData_1.FixedCustomData));
+}());
 exports.CommerceRequest = CommerceRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houlak/plexo-sdk",
-  "version": "0.1.7-fx",
+  "version": "0.1.8-fx",
   "description": "Node SDK for Plexo payment services",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",