ggez-banking-sdk 0.4.6 → 0.4.8

package/dist/api/api.js

@@ -1,6 +1,5 @@
 import { CookiesHelper } from "../helper/storage/cookiesHelper";
 import { AccountProxy, AuthProxy, BlockchainProxy, IPAddressAndLocationProxy, LimitedProxy, OrderProxy, OrganizationProxy, ProgramProxy, PromotionProxy, TransactionProxy, UserProxy, } from "./proxy";
-import { AuthService } from "./service";
 import { DefaultClientContextProvider } from "./context";
 class API {
     context;
@@ -17,26 +16,29 @@ class API {
     user;
     cookiesHelper;
     constructor(clientData, errorHandler) {
+        this.cookiesHelper = new CookiesHelper(clientData.programId, clientData.domain, errorHandler);
         this.context = new DefaultClientContextProvider({
             baseUrl: clientData.baseUrl,
             nodeUrl: clientData.nodeUrl,
             programId: clientData.programId,
             lang: clientData.lang,
-            installationId: clientData.installationId,
         });
-        this.cookiesHelper = new CookiesHelper(String(clientData.programId), clientData.domain ?? "", errorHandler);
-        const authService = new AuthService({ context: this.context, errorHandler });
-        this.auth = new AuthProxy(this.context, authService, this.cookiesHelper);
-        this.account = new AccountProxy(this.context, errorHandler);
-        this.blockchain = new BlockchainProxy(this.context, errorHandler);
-        this.order = new OrderProxy(this.context, errorHandler);
-        this.limited = new LimitedProxy(this.context, errorHandler);
-        this.organization = new OrganizationProxy(this.context, errorHandler);
-        this.program = new ProgramProxy(this.context, errorHandler);
-        this.promotion = new PromotionProxy(this.context, errorHandler);
-        this.ipAddress = new IPAddressAndLocationProxy(this.context, errorHandler);
-        this.transaction = new TransactionProxy(this.context, errorHandler);
-        this.user = new UserProxy(this.context, errorHandler);
+        const proxyData = {
+            context: this.context,
+            errorHandler,
+            cookiesHelper: this.cookiesHelper,
+        };
+        this.auth = new AuthProxy(proxyData);
+        this.account = new AccountProxy(proxyData);
+        this.blockchain = new BlockchainProxy(proxyData);
+        this.order = new OrderProxy(proxyData);
+        this.limited = new LimitedProxy(proxyData);
+        this.organization = new OrganizationProxy(proxyData);
+        this.program = new ProgramProxy(proxyData);
+        this.promotion = new PromotionProxy(proxyData);
+        this.ipAddress = new IPAddressAndLocationProxy(proxyData);
+        this.transaction = new TransactionProxy(proxyData);
+        this.user = new UserProxy(proxyData);
     }
     async logout() {
         this.context.setToken("");

package/dist/api/context/defaultClientContextProvider.js

@@ -22,7 +22,7 @@ class DefaultClientContextProvider {
         return this.nodeUrl;
     }
     getProgramId() {
-        return this.programId;
+        return Number(this.programId);
     }
     getLang() {
         return this.lang;

package/dist/api/proxy/account.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters } from "../../types";
 import { BaseProxy } from "./base";
 declare class AccountProxy extends BaseProxy {
     private accountService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     get: (accountId: number) => Promise<import("../..").ApiResponse<import("../..").AccountData>>;
     getLimits: (accountId: number) => Promise<import("../..").ApiResponse<import("../..").AccountData>>;
 }

package/dist/api/proxy/account.js

@@ -2,9 +2,9 @@ import { AccountService } from "../service/account";
 import { BaseProxy } from "./base";
 class AccountProxy extends BaseProxy {
     accountService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.accountService = new AccountService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.accountService = new AccountService(data);
     }
     // #region "GET"
     get = async (accountId) => {

package/dist/api/proxy/auth.d.ts

@@ -1,13 +1,9 @@
-import type { AuthService } from "../service/auth";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import type { IGenerateLimitedTokenData } from "../../types/api/data/auth";
-import type { ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
-import { CookiesHelper } from "../../helper/storage/cookiesHelper";
-declare class AuthProxy {
-    private context;
+import type { BaseProxyParameters, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
+import { BaseProxy } from "./base";
+declare class AuthProxy extends BaseProxy {
     private authService;
-    private cookiesHelper;
-    constructor(context: ClientContextProvider, authService: AuthService, cookiesHelper: CookiesHelper);
+    constructor(data: BaseProxyParameters);
     private login;
     loginUserCredentials(data: ILoginUserCredentialsData): Promise<import("../..").ApiResponse<import("../..").TokenData>>;
     loginDeviceCredentials(data: ILoginDeviceCredentialsData): Promise<import("../..").ApiResponse<import("../..").TokenData>>;

package/dist/api/proxy/auth.js

@@ -1,13 +1,12 @@
+import { AuthService } from "../service/auth";
 import { ResultHelper } from "../../helper/api/resultHelper";
 import { fillLoginDeviceCredentialsData, fillLoginGoogleCredentialsData, fillLoginUserCredentialsData, } from "../data";
-class AuthProxy {
-    context;
+import { BaseProxy } from "./base";
+class AuthProxy extends BaseProxy {
     authService;
-    cookiesHelper;
-    constructor(context, authService, cookiesHelper) {
-        this.context = context;
-        this.authService = authService;
-        this.cookiesHelper = cookiesHelper;
+    constructor(data) {
+        super(data);
+        this.authService = new AuthService(data);
     }
     async login(data) {
         const response = await this.authService.login(data);

package/dist/api/proxy/base.d.ts

@@ -1,6 +1,9 @@
-import type { ErrorHandler } from "../../types";
+import { CookiesHelper } from "../..";
+import type { BaseProxyParameters, ClientContextProvider, ErrorHandler } from "../../types";
 declare abstract class BaseProxy {
+    protected context: ClientContextProvider;
     protected errorHandler: ErrorHandler;
-    constructor(errorHandler: ErrorHandler);
+    protected cookiesHelper: CookiesHelper;
+    constructor(data: BaseProxyParameters);
 }
 export { BaseProxy };

package/dist/api/proxy/base.js

@@ -1,7 +1,11 @@
 class BaseProxy {
+    context;
     errorHandler;
-    constructor(errorHandler) {
-        this.errorHandler = errorHandler;
+    cookiesHelper;
+    constructor(data) {
+        this.context = data.context;
+        this.errorHandler = data.errorHandler;
+        this.cookiesHelper = data.cookiesHelper;
     }
 }
 export { BaseProxy };

package/dist/api/proxy/blockchain.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types";
 import { BaseProxy } from "./base";
 declare class BlockchainProxy extends BaseProxy {
     private blockchainService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     send: (data: IBlockchainSendRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;
     multiSend: (data: IBlockchainMultiSendRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;
     delegate: (data: IBlockchainDelegateRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;

package/dist/api/proxy/blockchain.js

@@ -3,22 +3,26 @@ import { BlockchainService } from "../service/blockchain";
 import { BaseProxy } from "./base";
 class BlockchainProxy extends BaseProxy {
     blockchainService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.blockchainService = new BlockchainService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.blockchainService = new BlockchainService(data);
     }
     // #region "POST"
     send = async (data) => {
-        return this.blockchainService.send(fillBlockchainSendData(data));
+        const blockchainData = fillBlockchainSendData(data);
+        return this.blockchainService.send(blockchainData);
     };
     multiSend = async (data) => {
-        return this.blockchainService.multiSend(fillBlockchainMultiSendData(data));
+        const blockchainData = fillBlockchainMultiSendData(data);
+        return this.blockchainService.multiSend(blockchainData);
     };
     delegate = async (data) => {
-        return this.blockchainService.delegate(fillBlockchainDelegateData(data));
+        const blockchainData = fillBlockchainDelegateData(data);
+        return this.blockchainService.delegate(blockchainData);
     };
     undelegate = async (data) => {
-        return this.blockchainService.undelegate(fillBlockchainUndelegateData(data));
+        const blockchainData = fillBlockchainUndelegateData(data);
+        return this.blockchainService.undelegate(blockchainData);
     };
 }
 export { BlockchainProxy };

package/dist/api/proxy/ipAddressAndLocation.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters } from "../../types";
 import { BaseProxy } from "./base";
 declare class IPAddressAndLocationProxy extends BaseProxy {
     private ipAddressAndLocationService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     getGeoCoordinates: () => Promise<import("../..").GeoCoordinates>;
     getIPAddress: () => Promise<string>;
     getGeoCoordinatesAndIPAddress: () => Promise<{

package/dist/api/proxy/ipAddressAndLocation.js

@@ -3,9 +3,9 @@ import { IPAddressAndLocationService } from "../service/ipAddressAndLocation";
 import { BaseProxy } from "./base";
 class IPAddressAndLocationProxy extends BaseProxy {
     ipAddressAndLocationService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.ipAddressAndLocationService = new IPAddressAndLocationService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.ipAddressAndLocationService = new IPAddressAndLocationService(data);
     }
     // #region "GET"
     getGeoCoordinates = () => {

package/dist/api/proxy/limited.d.ts

@@ -1,9 +1,8 @@
-import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, IValidateForgetPasswordData, IConfirmForgetPasswordData, ErrorHandler, ICheckForgetPasswordData } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, IValidateForgetPasswordData, IConfirmForgetPasswordData, ICheckForgetPasswordData, BaseProxyParameters } from "../../types";
 import { BaseProxy } from "./base";
 declare class LimitedProxy extends BaseProxy {
     private limitedService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     checkForgetPassword: (data: ICheckForgetPasswordData) => Promise<import("../..").ApiResponse<import("../..").ForgetSecurityData>>;
     validateForgetPassword: (data: IValidateForgetPasswordData) => Promise<import("../..").ApiResponse<import("../..").ForgetSecurityData>>;
     confirmForgetPassword: (data: IConfirmForgetPasswordData) => Promise<import("../..").ApiResponse<import("../..").ForgetSecurityData>>;

package/dist/api/proxy/limited.js

@@ -3,37 +3,46 @@ import { LimitedService } from "../service/limited";
 import { BaseProxy } from "./base";
 class LimitedProxy extends BaseProxy {
     limitedService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.limitedService = new LimitedService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.limitedService = new LimitedService(data);
     }
     // #region "POST"
     checkForgetPassword = async (data) => {
-        return this.limitedService.checkForgetSecurityData(fillCheckForgetPasswordData(data));
+        const forgetSecurityData = fillCheckForgetPasswordData(data);
+        return this.limitedService.checkForgetSecurityData(forgetSecurityData);
     };
     validateForgetPassword = async (data) => {
-        return this.limitedService.validateForgetSecurityData(fillValidateForgetPasswordData(data));
+        const forgetSecurityData = fillValidateForgetPasswordData(data);
+        return this.limitedService.validateForgetSecurityData(forgetSecurityData);
     };
     confirmForgetPassword = async (data) => {
-        return this.limitedService.confirmForgetSecurityData(fillConfirmForgetPasswordData(data));
+        const forgetSecurityData = fillConfirmForgetPasswordData(data);
+        return this.limitedService.confirmForgetSecurityData(forgetSecurityData);
     };
     validateEmail = async (data) => {
-        return this.limitedService.validateSecurityData(fillValidateEmailData(data));
+        const validateSecurityData = fillValidateEmailData(data);
+        return this.limitedService.validateSecurityData(validateSecurityData);
     };
     validatePhone = async (data) => {
-        return this.limitedService.validateSecurityData(fillValidatePhoneData(data));
+        const validateSecurityData = fillValidatePhoneData(data);
+        return this.limitedService.validateSecurityData(validateSecurityData);
     };
     verifyEmail = async (data) => {
-        return this.limitedService.verifySecurityData(fillVerifyEmailData(data));
+        const verifySecurityData = fillVerifyEmailData(data);
+        return this.limitedService.verifySecurityData(verifySecurityData);
     };
     verifyPhone = async (data) => {
-        return this.limitedService.verifySecurityData(fillVerifyPhoneData(data));
+        const verifySecurityData = fillVerifyPhoneData(data);
+        return this.limitedService.verifySecurityData(verifySecurityData);
     };
     confirmEmail = async (data) => {
-        return this.limitedService.confirmSecurityData(fillConfirmEmailData(data));
+        const confirmSecurityData = fillConfirmEmailData(data);
+        return this.limitedService.confirmSecurityData(confirmSecurityData);
     };
     confirmPhone = async (data) => {
-        return this.limitedService.confirmSecurityData(fillConfirmPhoneData(data));
+        const confirmSecurityData = fillConfirmPhoneData(data);
+        return this.limitedService.confirmSecurityData(confirmSecurityData);
     };
 }
 export { LimitedProxy };

package/dist/api/proxy/order.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler, ICreateOrderData } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters, ICreateOrderData } from "../../types";
 import { BaseProxy } from "./base";
 declare class OrderProxy extends BaseProxy {
     private orderService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     createOrder: (data: ICreateOrderData) => Promise<import("../..").ApiResponse<import("../..").OrderData>>;
 }
 export { OrderProxy };

package/dist/api/proxy/order.js

@@ -3,13 +3,14 @@ import { OrderService } from "../service/order";
 import { BaseProxy } from "./base";
 class OrderProxy extends BaseProxy {
     orderService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.orderService = new OrderService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.orderService = new OrderService(data);
     }
     // #region "POST"
     createOrder = async (data) => {
-        return this.orderService.create(fillCreateOrderData(data));
+        const orderData = fillCreateOrderData(data);
+        return this.orderService.create(orderData);
     };
 }
 export { OrderProxy };

package/dist/api/proxy/organization.d.ts

@@ -1,11 +1,8 @@
-import type { ErrorHandler } from "../../types";
-import type { ICreateOrganizationData, IUpdateOrganizationData, IUploadOrganizationDocumentData } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters, ICreateOrganizationData, IUpdateOrganizationData, IUploadOrganizationDocumentData } from "../../types";
 import { BaseProxy } from "./base";
 declare class OrganizationProxy extends BaseProxy {
-    private context;
     private organizationService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     getOrganization: (id: number) => Promise<import("../..").ApiResponse<import("../..").OrganizationData>>;
     createOrganization: (data: ICreateOrganizationData) => Promise<import("../..").ApiResponse<import("../..").OrganizationData>>;
     uploadDocument: (data: IUploadOrganizationDocumentData) => Promise<import("../..").ApiResponse<import("../..").DocumentData>>;

package/dist/api/proxy/organization.js

@@ -2,12 +2,10 @@ import { fillCreateOrganizationData, fillCreateOrganizationDocumentData, fillUpd
 import { OrganizationService } from "../service/organization";
 import { BaseProxy } from "./base";
 class OrganizationProxy extends BaseProxy {
-    context;
     organizationService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.context = context;
-        this.organizationService = new OrganizationService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.organizationService = new OrganizationService(data);
     }
     // #region "GET"
     getOrganization = async (id) => {
@@ -16,15 +14,18 @@ class OrganizationProxy extends BaseProxy {
     // #endregion
     // #region "POST"
     createOrganization = async (data) => {
-        return this.organizationService.create(fillCreateOrganizationData(data, this.context.getUserId()));
+        const organizationData = fillCreateOrganizationData(data, this.context.getUserId());
+        return this.organizationService.create(organizationData);
     };
     uploadDocument = async (data) => {
-        return this.organizationService.createDocument(data.id, fillCreateOrganizationDocumentData(data));
+        const documentData = fillCreateOrganizationDocumentData(data);
+        return this.organizationService.createDocument(data.id, documentData);
     };
     // #endregion
     // #region "PUT"
     updateOrganization = async (data) => {
-        return this.organizationService.update(data.id, fillUpdateOrganizationData(data, this.context.getUserId()));
+        const organizationData = fillUpdateOrganizationData(data, this.context.getUserId());
+        return this.organizationService.update(data.id, organizationData);
     };
     // #endregion
     // #region "DELETE"

package/dist/api/proxy/program.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters } from "../../types";
 import { BaseProxy } from "./base";
 declare class ProgramProxy extends BaseProxy {
     private programService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     getSystemFeatures: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;
     getBin: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;
     getSignUp: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;

package/dist/api/proxy/program.js

@@ -2,9 +2,9 @@ import { ProgramService } from "../service/program";
 import { BaseProxy } from "./base";
 class ProgramProxy extends BaseProxy {
     programService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.programService = new ProgramService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.programService = new ProgramService(data);
     }
     getSystemFeatures = async () => this.programService.getSystemFeatures();
     getBin = async () => this.programService.getBin();

package/dist/api/proxy/promotion.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler, GGEZGiftRewards } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters, GGEZGiftRewards } from "../../types";
 import { BaseProxy } from "./base";
 declare class PromotionProxy extends BaseProxy {
     private promotionService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     getPromotionByCode: (code: string) => Promise<import("../..").ApiResponse<import("../..").PromotionDetails>>;
     getTwitterSpotlightPostIds: () => Promise<import("../..").ApiResponse<import("../..").TwitterSpotlightPostIdsResult>>;
     incrementPromotionParticipants: (data: GGEZGiftRewards) => Promise<import("../..").ApiResponse<import("../..").PromotionIncrementResult>>;

package/dist/api/proxy/promotion.js

@@ -2,9 +2,9 @@ import { PromotionService } from "../service/promotion";
 import { BaseProxy } from "./base";
 class PromotionProxy extends BaseProxy {
     promotionService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.promotionService = new PromotionService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.promotionService = new PromotionService(data);
     }
     // #region "GET"
     getPromotionByCode = async (code) => {
@@ -16,7 +16,8 @@ class PromotionProxy extends BaseProxy {
     // #endregion
     // #region "PUT"
     incrementPromotionParticipants = async (data) => {
-        return this.promotionService.incrementPromotionParticipants(data);
+        const giftRewards = data;
+        return this.promotionService.incrementPromotionParticipants(giftRewards);
     };
 }
 export { PromotionProxy };

package/dist/api/proxy/transaction.d.ts

@@ -1,9 +1,8 @@
-import type { ErrorHandler, IInquiryTransactionData, ICreateSystemTransactionData, ICreateGatewayCryptoTransactionData, ICreateBlockchainTransactionData, ICreateBlockchainTransferTransactionData } from "../../types";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { BaseProxyParameters, IInquiryTransactionData, ICreateSystemTransactionData, ICreateGatewayCryptoTransactionData, ICreateBlockchainTransactionData, ICreateBlockchainTransferTransactionData } from "../../types";
 import { BaseProxy } from "./base";
 declare class TransactionProxy extends BaseProxy {
     private transactionService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     inquiryTransaction: (params: IInquiryTransactionData) => Promise<import("../..").ApiResponse<import("../..").TransactionResultInquiry>>;
     createSystemTransaction: (data: ICreateSystemTransactionData) => Promise<import("../..").ApiResponse<import("../..").TransactionData>>;
     createBlockchainTransaction: (data: ICreateBlockchainTransactionData) => Promise<import("../..").ApiResponse<import("../..").TransactionData>>;

package/dist/api/proxy/transaction.js

@@ -3,27 +3,32 @@ import { TransactionService } from "../service/transaction";
 import { BaseProxy } from "./base";
 class TransactionProxy extends BaseProxy {
     transactionService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.transactionService = new TransactionService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.transactionService = new TransactionService(data);
     }
     // #region "GET"
     inquiryTransaction = async (params) => {
-        return this.transactionService.inquiry(fillTransactionInquiryData(params));
+        const transactionInquiry = fillTransactionInquiryData(params);
+        return this.transactionService.inquiry(transactionInquiry);
     };
     // #endregion
     // #region "POST"
     createSystemTransaction = async (data) => {
-        return this.transactionService.create(fillCreateSystemTransactionData(data));
+        const transactionData = fillCreateSystemTransactionData(data);
+        return this.transactionService.create(transactionData);
     };
     createBlockchainTransaction = async (data) => {
-        return this.transactionService.create(fillCreateBlockchainTransactionData(data));
+        const transactionData = fillCreateBlockchainTransactionData(data);
+        return this.transactionService.create(transactionData);
     };
     createBlockchainTransferTransaction = async (data) => {
-        return this.transactionService.create(fillCreateBlockchainTransferTransactionData(data));
+        const transactionData = fillCreateBlockchainTransferTransactionData(data);
+        return this.transactionService.create(transactionData);
     };
     createGatewayCryptoTransaction = async (data) => {
-        return this.transactionService.create(fillCreateGatewayCryptoTransactionData(data));
+        const transactionData = fillCreateGatewayCryptoTransactionData(data);
+        return this.transactionService.create(transactionData);
     };
 }
 export { TransactionProxy };

package/dist/api/proxy/user.d.ts

@@ -1,11 +1,10 @@
-import type { ErrorHandler, IActivateGoogleAuthData, IConfirmDeviceData, IConfirmEmailData, IConfirmPhoneData, ICreateAddressData, ICreateBankAccountData, ICreateDeviceData, ICreateEmailData, ICreateIdentificationData, ICreatePhoneData, ICreateTicketData, ICreateUserData, ICreateUserWithGoogleData, IDeactivateGoogleAuthData, IDeleteAddressData, IDeleteBankAccountData, IDeleteDeviceData, IDeleteEmailData, IDeleteGoogleAuthData, IDeleteIdentificationData, IDeletePhoneData, ILogoutDeviceData, IMakeAddressPrimaryData, IMakeBankAccountPrimaryData, IMakeEmailPrimaryData, IMakePhonePrimaryData, IResetPasswordData, IResetSecurityCodeData, IResetSecurityQuestionsData, ISendEmailOTPData, ISendPhoneOTPData, IUpdateAddressData, IUpdateBankAccountData, IUpdateDeviceData, IUpdateEmailData, IUpdateIdentificationData, IUpdatePersonalInfoData, IUpdatePhoneData, IUpdatePreferencesData, IUploadDocumentData, IUploadProfilePictureData, IValidateSecurityCodeData, IVerifyDeviceData, IVerifyEmailData, IVerifyPhoneData } from "../../types";
+import type { BaseProxyParameters, IActivateGoogleAuthData, IConfirmDeviceData, IConfirmEmailData, IConfirmPhoneData, ICreateAddressData, ICreateBankAccountData, ICreateDeviceData, ICreateEmailData, ICreateIdentificationData, ICreatePhoneData, ICreateTicketData, ICreateUserData, ICreateUserWithGoogleData, IDeactivateGoogleAuthData, IDeleteAddressData, IDeleteBankAccountData, IDeleteDeviceData, IDeleteEmailData, IDeleteGoogleAuthData, IDeleteIdentificationData, IDeletePhoneData, ILogoutDeviceData, IMakeAddressPrimaryData, IMakeBankAccountPrimaryData, IMakeEmailPrimaryData, IMakePhonePrimaryData, IResetPasswordData, IResetSecurityCodeData, IResetSecurityQuestionsData, ISendEmailOTPData, ISendPhoneOTPData, IUpdateAddressData, IUpdateBankAccountData, IUpdateDeviceData, IUpdateEmailData, IUpdateIdentificationData, IUpdatePersonalInfoData, IUpdatePhoneData, IUpdatePreferencesData, IUploadDocumentData, IUploadProfilePictureData, IValidateSecurityCodeData, IVerifyDeviceData, IVerifyEmailData, IVerifyPhoneData } from "../../types";
 import type { ResetUserSecurity } from "../../types/banking/user/resetUserSecurity";
 import type { IUpdateUserTypeData } from "../../types/api/data/user/type";
-import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import { BaseProxy } from "./base";
 declare class UserProxy extends BaseProxy {
     private userService;
-    constructor(context: ClientContextProvider, errorHandler: ErrorHandler);
+    constructor(data: BaseProxyParameters);
     getUser: () => Promise<import("../..").ApiResponse<import("../..").UserData>>;
     getTermsAndConditions: () => Promise<import("../..").ApiResponse<import("../..").UserData>>;
     getSecurity: () => Promise<import("../..").ApiResponse<import("../..").UserData>>;

package/dist/api/proxy/user.js

@@ -3,9 +3,9 @@ import { UserService } from "../service/user";
 import { BaseProxy } from "./base";
 class UserProxy extends BaseProxy {
     userService;
-    constructor(context, errorHandler) {
-        super(errorHandler);
-        this.userService = new UserService({ context, errorHandler });
+    constructor(data) {
+        super(data);
+        this.userService = new UserService(data);
     }
     // #region "GET"
     getUser = async () => this.userService.getUser();
@@ -30,65 +30,206 @@ class UserProxy extends BaseProxy {
     getDeviceHistory = async () => this.userService.getDeviceHistory();
     // #endregion
     // #region "POST"
-    createUser = async (data) => this.userService.createUser(fillCreateUserData(data));
-    createUserWithGoogle = async (data) => this.userService.createUser(await fillCreateUserWithGoogleData(data));
-    createPhone = async (data) => this.userService.createPhone(fillCreatePhoneData(data));
-    createIdentification = async (data) => this.userService.createIdentification(fillCreateIdentificationData(data));
+    createUser = async (data) => {
+        const userData = fillCreateUserData(data);
+        return this.userService.createUser(userData);
+    };
+    createUserWithGoogle = async (data) => {
+        const userData = await fillCreateUserWithGoogleData(data);
+        return this.userService.createUser(userData);
+    };
+    createPhone = async (data) => {
+        const userData = fillCreatePhoneData(data);
+        return this.userService.createPhone(userData);
+    };
+    createIdentification = async (data) => {
+        const userData = fillCreateIdentificationData(data);
+        return this.userService.createIdentification(userData);
+    };
     createExternalAuth = async (data) => this.userService.createExternalAuth(data);
-    createEmail = async (data) => this.userService.createEmail(fillCreateEmailData(data));
+    createEmail = async (data) => {
+        const userData = fillCreateEmailData(data);
+        return this.userService.createEmail(userData);
+    };
     createCurrency = async (data) => this.userService.createCurrency(data);
     createCreditCard = async (data) => this.userService.createCreditCard(data);
-    createTicket = async (data) => this.userService.createTicket(fillCreateTicketData(data));
-    createBankAccount = async (data) => this.userService.createBankAccount(fillCreateBankAccountData(data));
-    createAddress = async (data) => this.userService.createAddress(fillCreateAddressData(data));
-    createDevice = async (data) => this.userService.createDevice(fillCreateDeviceData(data));
+    createTicket = async (data) => {
+        const userData = fillCreateTicketData(data);
+        return this.userService.createTicket(userData);
+    };
+    createBankAccount = async (data) => {
+        const userData = fillCreateBankAccountData(data);
+        return this.userService.createBankAccount(userData);
+    };
+    createAddress = async (data) => {
+        const userData = fillCreateAddressData(data);
+        return this.userService.createAddress(userData);
+    };
+    createDevice = async (data) => {
+        const userData = fillCreateDeviceData(data);
+        return this.userService.createDevice(userData);
+    };
     securityAccess = async (data) => this.userService.securityAccess(data);
-    uploadDocument = async (data) => this.userService.uploadDocument(fillUploadDocumentData(data));
-    updateProfilePicture = async (data) => this.userService.uploadDocument(fillUploadProfilePictureData(data));
+    uploadDocument = async (data) => {
+        const documentData = fillUploadDocumentData(data);
+        return this.userService.uploadDocument(documentData);
+    };
+    updateProfilePicture = async (data) => {
+        const documentData = fillUploadProfilePictureData(data);
+        return this.userService.uploadDocument(documentData);
+    };
     verifySecurityData = async (data) => this.userService.verifySecurityData(data);
-    verifyEmail = async (data) => this.userService.verifySecurityData(fillVerifyEmailData(data));
-    sendEmailOTP = async (data) => this.userService.verifySecurityData(fillSendEmailOTPData(data));
-    verifyPhone = async (data) => this.userService.verifySecurityData(fillVerifyPhoneData(data));
-    sendPhoneOTP = async (data) => this.userService.verifySecurityData(fillSendPhoneOTPData(data));
-    verifyDevice = async (data) => this.userService.verifySecurityData(fillVerifyDeviceData(data));
+    verifyEmail = async (data) => {
+        const verifySecurityData = fillVerifyEmailData(data);
+        return this.userService.verifySecurityData(verifySecurityData);
+    };
+    sendEmailOTP = async (data) => {
+        const verifySecurityData = fillSendEmailOTPData(data);
+        return this.userService.verifySecurityData(verifySecurityData);
+    };
+    verifyPhone = async (data) => {
+        const verifySecurityData = fillVerifyPhoneData(data);
+        return this.userService.verifySecurityData(verifySecurityData);
+    };
+    sendPhoneOTP = async (data) => {
+        const verifySecurityData = fillSendPhoneOTPData(data);
+        return this.userService.verifySecurityData(verifySecurityData);
+    };
+    verifyDevice = async (data) => {
+        const verifySecurityData = fillVerifyDeviceData(data);
+        return this.userService.verifySecurityData(verifySecurityData);
+    };
     confirmSecurityData = async (data) => this.userService.confirmSecurityData(data);
-    confirmEmail = async (data) => this.userService.confirmSecurityData(fillConfirmEmailData(data));
-    confirmPhone = async (data) => this.userService.confirmSecurityData(fillConfirmPhoneData(data));
-    confirmDevice = async (data) => this.userService.confirmSecurityData(fillConfirmDeviceData(data));
-    resetSecurityData = async (data) => this.userService.resetSecurityData(data);
+    confirmEmail = async (data) => {
+        const confirmSecurityData = fillConfirmEmailData(data);
+        return this.userService.confirmSecurityData(confirmSecurityData);
+    };
+    confirmPhone = async (data) => {
+        const confirmSecurityData = fillConfirmPhoneData(data);
+        return this.userService.confirmSecurityData(confirmSecurityData);
+    };
+    confirmDevice = async (data) => {
+        const confirmSecurityData = fillConfirmDeviceData(data);
+        return this.userService.confirmSecurityData(confirmSecurityData);
+    };
+    resetSecurityData = async (data) => {
+        const securityData = data;
+        return this.userService.resetSecurityData(securityData);
+    };
     enrollGoogleAuth = async () => this.userService.enrollGoogleAuth(fillEnrollGoogleAuthData());
-    activateGoogleAuth = async (data) => this.userService.activateGoogleAuth(fillActivateGoogleAuthData(data));
-    deleteGoogleAuth = async (data) => this.userService.deleteGoogleAuth(fillDeleteGoogleAuthData(data));
-    deactivateGoogleAuth = async (data) => this.userService.deactivateGoogleAuth(fillDeactivateGoogleAuthData(data));
+    activateGoogleAuth = async (data) => {
+        const userData = fillActivateGoogleAuthData(data);
+        return this.userService.activateGoogleAuth(userData);
+    };
+    deleteGoogleAuth = async (data) => {
+        const userData = fillDeleteGoogleAuthData(data);
+        return this.userService.deleteGoogleAuth(userData);
+    };
+    deactivateGoogleAuth = async (data) => {
+        const userData = fillDeactivateGoogleAuthData(data);
+        return this.userService.deactivateGoogleAuth(userData);
+    };
     // #endregion
     // #region "PUT"
     updateUser = async (data) => this.userService.updateUser(data);
-    resetPassword = async (data) => this.userService.resetSecurityData(fillResetPasswordData(data));
-    resetSecurityCode = async (data) => this.userService.resetSecurityData(fillResetSecurityCodeData(data));
-    resetSecurityQuestions = async (data) => this.userService.resetSecurityData(fillResetSecurityQuestionsData(data));
-    validateSecurityCode = async (data) => this.userService.validateSecurityData(fillValidateSecurityCodeData(data));
-    updatePreferences = async (data) => this.userService.updatePreferences(fillUpdatePreferencesData(data));
-    updatePhone = async (data) => this.userService.updatePhone(fillUpdatePhoneData(data));
-    makePhonePrimary = async (data) => this.userService.updatePhone(fillMakePhonePrimaryData(data));
-    updatePersonalInfo = async (data) => this.userService.updatePersonalInfo(fillUpdatePersonalInfoData(data));
-    updateIdentification = async (data) => this.userService.updateIdentification(fillUpdateIdentificationData(data));
+    resetPassword = async (data) => {
+        const resetSecurityData = fillResetPasswordData(data);
+        return this.userService.resetSecurityData(resetSecurityData);
+    };
+    resetSecurityCode = async (data) => {
+        const resetSecurityData = fillResetSecurityCodeData(data);
+        return this.userService.resetSecurityData(resetSecurityData);
+    };
+    resetSecurityQuestions = async (data) => {
+        const resetSecurityData = fillResetSecurityQuestionsData(data);
+        return this.userService.resetSecurityData(resetSecurityData);
+    };
+    validateSecurityCode = async (data) => {
+        const validateSecurityData = fillValidateSecurityCodeData(data);
+        return this.userService.validateSecurityData(validateSecurityData);
+    };
+    updatePreferences = async (data) => {
+        const userData = fillUpdatePreferencesData(data);
+        return this.userService.updatePreferences(userData);
+    };
+    updatePhone = async (data) => {
+        const userData = fillUpdatePhoneData(data);
+        return this.userService.updatePhone(userData);
+    };
+    makePhonePrimary = async (data) => {
+        const userData = fillMakePhonePrimaryData(data);
+        return this.userService.updatePhone(userData);
+    };
+    updatePersonalInfo = async (data) => {
+        const userData = fillUpdatePersonalInfoData(data);
+        return this.userService.updatePersonalInfo(userData);
+    };
+    updateIdentification = async (data) => {
+        const userData = fillUpdateIdentificationData(data);
+        return this.userService.updateIdentification(userData);
+    };
     updateExternalAuth = async (data) => this.userService.updateExternalAuth(data);
-    updateEmail = async (data) => this.userService.updateEmail(fillUpdateEmailData(data));
-    makeEmailPrimary = async (data) => this.userService.updateEmail(fillMakeEmailPrimaryData(data));
-    updateBankAccount = async (data) => this.userService.updateBankAccount(fillUpdateBankAccountData(data));
-    makeBankAccountPrimary = async (data) => this.userService.updateBankAccount(fillMakeBankAccountPrimaryData(data));
-    updateAddress = async (data) => this.userService.updateAddress(fillUpdateAddressData(data));
-    makeAddressPrimary = async (data) => this.userService.updateAddress(fillMakeAddressPrimaryData(data));
-    updateDevice = async (data) => this.userService.updateDevice(fillUpdateDeviceData(data));
-    logoutDevice = async (data) => this.userService.logoutDevice(fillLogoutDeviceData(data));
-    updateUserType = async (data) => this.userService.updateUserType(fillUpdateUserTypeData(data));
+    updateEmail = async (data) => {
+        const userData = fillUpdateEmailData(data);
+        return this.userService.updateEmail(userData);
+    };
+    makeEmailPrimary = async (data) => {
+        const userData = fillMakeEmailPrimaryData(data);
+        return this.userService.updateEmail(userData);
+    };
+    updateBankAccount = async (data) => {
+        const userData = fillUpdateBankAccountData(data);
+        return this.userService.updateBankAccount(userData);
+    };
+    makeBankAccountPrimary = async (data) => {
+        const userData = fillMakeBankAccountPrimaryData(data);
+        return this.userService.updateBankAccount(userData);
+    };
+    updateAddress = async (data) => {
+        const userData = fillUpdateAddressData(data);
+        return this.userService.updateAddress(userData);
+    };
+    makeAddressPrimary = async (data) => {
+        const userData = fillMakeAddressPrimaryData(data);
+        return this.userService.updateAddress(userData);
+    };
+    updateDevice = async (data) => {
+        const userData = fillUpdateDeviceData(data);
+        return this.userService.updateDevice(userData);
+    };
+    logoutDevice = async (data) => {
+        const userData = fillLogoutDeviceData(data);
+        return this.userService.logoutDevice(userData);
+    };
+    updateUserType = async (data) => {
+        const userData = fillUpdateUserTypeData(data);
+        return this.userService.updateUserType(userData);
+    };
     // #endregion
     // #region "DELETE"
-    deleteAddress = async (data) => this.userService.deleteAddress(fillDeleteAddressData(data));
-    deleteBankAccount = async (data) => this.userService.deleteBankAccount(fillDeleteBankAccountData(data));
-    deleteDevice = async (data) => this.userService.deleteDevice(fillDeleteDeviceData(data));
-    deleteEmail = async (data) => this.userService.deleteEmail(fillDeleteEmailData(data));
-    deleteIdentification = async (data) => this.userService.deleteIdentification(fillDeleteIdentificationData(data));
-    deletePhone = async (data) => this.userService.deletePhone(fillDeletePhoneData(data));
+    deleteAddress = async (data) => {
+        const userData = fillDeleteAddressData(data);
+        return this.userService.deleteAddress(userData);
+    };
+    deleteBankAccount = async (data) => {
+        const userData = fillDeleteBankAccountData(data);
+        return this.userService.deleteBankAccount(userData);
+    };
+    deleteDevice = async (data) => {
+        const userData = fillDeleteDeviceData(data);
+        return this.userService.deleteDevice(userData);
+    };
+    deleteEmail = async (data) => {
+        const userData = fillDeleteEmailData(data);
+        return this.userService.deleteEmail(userData);
+    };
+    deleteIdentification = async (data) => {
+        const userData = fillDeleteIdentificationData(data);
+        return this.userService.deleteIdentification(userData);
+    };
+    deletePhone = async (data) => {
+        const userData = fillDeletePhoneData(data);
+        return this.userService.deletePhone(userData);
+    };
 }
 export { UserProxy };

package/dist/api/service/base.d.ts

@@ -1,11 +1,13 @@
 import { AxiosInstance } from "axios";
-import type { ApiResponse, BaseServiceParameters, ErrorHandler } from "../../types/api/service/base";
+import type { BaseServiceParameters } from "../../types/api/service/base";
 import type { ClientContextProvider } from "../../types/api/context/clientContext";
 import type { RequestFlag } from "../../types/helper/api/requestBuilder";
 import type { BaseResult } from "../../types/banking/common/baseresult";
+import { ApiResponse, ErrorHandler } from "../..";
 declare abstract class BaseService {
     protected abstract endpoint: string;
     protected context: ClientContextProvider;
+    private cookiesHelper;
     protected axiosInstance: AxiosInstance;
     protected errorHandler: ErrorHandler;
     constructor(data: BaseServiceParameters);

package/dist/api/service/base.js

@@ -4,17 +4,19 @@ import { ResponseHelper } from "../../helper/api/responseHelper";
 import { HeaderKeys } from "../../constant/constant";
 class BaseService {
     context;
+    cookiesHelper;
     axiosInstance;
     errorHandler;
     constructor(data) {
         this.context = data.context;
+        this.cookiesHelper = data.cookiesHelper;
         this.errorHandler = data.errorHandler;
         this.axiosInstance = axios.create();
         this.axiosInstance.interceptors.request.use((req) => this.onRequest(req));
         this.axiosInstance.interceptors.response.use((response) => this.onResponse(response), (error) => this.onError(error));
     }
     async onRequest(req) {
-        AxiosHelper.injectBaseHeaders(req, this.context, this.endpoint);
+        await AxiosHelper.injectBaseHeaders(req, this.context, this.cookiesHelper, this.endpoint);
         AxiosHelper.injectBaseBodyProperties(req);
         return req;
     }

package/dist/helper/api/axiosHelper.js

@@ -41,11 +41,11 @@ class AxiosHelper {
             config.headers = {};
         config.headers[key] = value;
     };
-    static injectBaseHeaders = (req, context, endpoint) => {
+    static injectBaseHeaders = async (req, context, cookiesHelper, endpoint) => {
         const token = context.getToken();
         const userId = context.getUserId();
         const lang = context.getLang();
-        const iid = context.getInstallationId();
+        const iid = await cookiesHelper.getIID();
         const baseURL = context.getBaseUrl();
         const nodeUrl = context.getNodeUrl();
         if (token)

package/dist/types/api/api.d.ts

@@ -1,9 +1,8 @@
 type ClientData = {
     baseUrl: string;
     nodeUrl: string;
-    programId: number;
+    programId: string;
     lang: string;
-    installationId: string;
-    domain?: string;
+    domain: string;
 };
 export type { ClientData };

package/dist/types/api/common/index.d.ts

@@ -0,0 +1,9 @@
+import { BaseResult } from "../../banking/common/baseresult";
+type ErrorHandler = (error: unknown) => void;
+type ApiResponse<T extends BaseResult> = {
+    data: T;
+    success: boolean;
+    message: string;
+    error: string | null;
+};
+export type { ApiResponse, ErrorHandler };

package/dist/types/api/context/clientContext.d.ts

@@ -1,7 +1,7 @@
 type InitialContext = {
     baseUrl: string;
     nodeUrl: string;
-    programId: number;
+    programId: string;
     lang?: string;
     installationId?: string;
     token?: string;

package/dist/types/api/index.d.ts

@@ -1,4 +1,6 @@
 export type * from "./api";
 export type * from "./context";
+export type * from "./common";
 export type * from "./data";
 export type * from "./service";
+export type * from "./proxy";

package/dist/types/api/proxy/index.d.ts

@@ -0,0 +1,9 @@
+import { CookiesHelper } from "../../../helper";
+import { ErrorHandler } from "../common";
+import { ClientContextProvider } from "../context";
+type BaseProxyParameters = {
+    context: ClientContextProvider;
+    errorHandler: ErrorHandler;
+    cookiesHelper: CookiesHelper;
+};
+export type { BaseProxyParameters };

package/dist/types/api/proxy/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/service/base.d.ts

@@ -1,15 +1,8 @@
 import type { ClientContextProvider } from "../context/clientContext";
-import type { BaseResult } from "../../banking/common/baseresult";
+import { CookiesHelper, ErrorHandler } from "../../..";
 type BaseServiceParameters = {
     context: ClientContextProvider;
     errorHandler: ErrorHandler;
+    cookiesHelper: CookiesHelper;
 };
-type ErrorHandler = (error: unknown) => void;
-type ApiResponse<T extends BaseResult> = {
-    data: T;
-    success: boolean;
-    message: string;
-    error: string | null;
-};
-export type { ApiResponse };
-export { BaseServiceParameters, ErrorHandler };
+export { BaseServiceParameters };

package/dist/types/api/service/index.d.ts

@@ -4,7 +4,6 @@ export type * from "./base";
 export type * from "./blockchain";
 export type * from "./ipAddressAndLocation";
 export type * from "./limited";
-export type * from "./openPayd";
 export type * from "./order";
 export type * from "./organization";
 export type * from "./program";

package/dist/types/helper/api/axiosHelper.d.ts

@@ -1,12 +1,13 @@
 import { AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
 import { GeoCoordinates } from "../../banking/common";
 import { ClientContextProvider } from "../..";
+import { CookiesHelper } from "../../..";
 type TGetAxiosConfig = (token: string, baseURL: string, lang?: string, installationId?: string) => AxiosRequestConfig;
 type TGetAuthAxiosConfig = (baseURL: string, lang: string, installationId: string) => AxiosRequestConfig;
 type TAddAxiosConfigHeader = (config: AxiosRequestConfig, key: string, value: string) => void;
 type TInjectRequest<D> = (req: InternalAxiosRequestConfig<D>) => InternalAxiosRequestConfig<D>;
 type InjectRequiredHeaders<D> = (req: InternalAxiosRequestConfig, userId: number) => InternalAxiosRequestConfig<D>;
-type InjectBaseHeaders<D> = (req: InternalAxiosRequestConfig, context: ClientContextProvider, endpoint: string) => InternalAxiosRequestConfig<D>;
+type InjectBaseHeaders<D> = (req: InternalAxiosRequestConfig, context: ClientContextProvider, cookiesHelper: CookiesHelper, endpoint: string) => Promise<InternalAxiosRequestConfig<D>>;
 type TInjectGeoCoordinates = <D extends {
     geo_coordinates: GeoCoordinates;
 }>(req: InternalAxiosRequestConfig<D>, geoCoordinates: GeoCoordinates) => InternalAxiosRequestConfig<D>;

package/dist/types/helper/geoHelper.d.ts

@@ -1,6 +1,6 @@
 import type { GeoCoordinates } from "../banking/common";
-import type { ApiResponse } from "../api/service/base";
 import type { IPAddressStringResult } from "../api/service/ipAddressAndLocation";
+import { ApiResponse } from "../api/common";
 type IPAddressAndLocation = {
     ip_address: string;
     country: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggez-banking-sdk",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "A Node.js package to handle GGEZ Banking API endpoints, Simplify the process of managing CRUD operations with this efficient and easy-to-use package.",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",

package/dist/types/api/service/openPayd.d.ts

@@ -1,3 +0,0 @@
-import { BaseServiceParameters } from "./base";
-type OpenPaydServiceParameters = BaseServiceParameters;
-export { OpenPaydServiceParameters };