ggez-banking-sdk 0.4.7 → 0.4.9

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,32 +16,31 @@ 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,
         });
-        this.cookiesHelper = new CookiesHelper(clientData.programId, clientData.domain, errorHandler);
-        const authService = new AuthService({
+        const proxyData = {
             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);
+            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("");
-        this.context.setUserId(0);
         await this.cookiesHelper.clearCredentialCookies();
     }
 }

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,19 +1,16 @@
+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);
-        if (ResultHelper.isApproved(response?.data?.result)) {
-            this.context.setToken(response.data.access_token);
-            this.context.setUserId(Number(response.data.user_id));
+        if (ResultHelper.isApproved(response.data.result)) {
             await this.cookiesHelper.setCredentialCookiesByTokenData(response.data);
         }
         return response;

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,9 +3,9 @@ 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) => {

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,9 +3,9 @@ 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) => {

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,9 +3,9 @@ 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) => {

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

@@ -1,11 +1,9 @@
-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);
+    userId(): Promise<number>;
     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,15 +2,13 @@ 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);
+    }
+    async userId() {
+        return this.cookiesHelper.getUserId();
     }
     // #region "GET"
     getOrganization = async (id) => {
@@ -19,7 +17,7 @@ class OrganizationProxy extends BaseProxy {
     // #endregion
     // #region "POST"
     createOrganization = async (data) => {
-        const organizationData = fillCreateOrganizationData(data, this.context.getUserId());
+        const organizationData = fillCreateOrganizationData(data, await this.userId());
         return this.organizationService.create(organizationData);
     };
     uploadDocument = async (data) => {
@@ -29,7 +27,7 @@ class OrganizationProxy extends BaseProxy {
     // #endregion
     // #region "PUT"
     updateOrganization = async (data) => {
-        const organizationData = fillUpdateOrganizationData(data, this.context.getUserId());
+        const organizationData = fillUpdateOrganizationData(data, await this.userId());
         return this.organizationService.update(data.id, organizationData);
     };
     // #endregion

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) => {

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,9 +3,9 @@ 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) => {

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();

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, CookiesHelper, ErrorHandler } from "../..";
 declare abstract class BaseService {
     protected abstract endpoint: string;
     protected context: ClientContextProvider;
+    protected cookiesHelper: CookiesHelper;
     protected axiosInstance: AxiosInstance;
     protected errorHandler: ErrorHandler;
     constructor(data: BaseServiceParameters);

package/dist/api/service/base.js

@@ -4,27 +4,31 @@ 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));
+        this.axiosInstance.interceptors.response.use((res) => this.onResponse(res), (err) => this.onError(err));
     }
+    // #region "Interceptors Handlers"
     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;
     }
-    onResponse(response) {
-        return ResponseHelper.onResponse(response);
+    onResponse(res) {
+        return ResponseHelper.onResponse(res);
     }
-    onError(error) {
-        this.errorHandler(error);
-        return ResponseHelper.onError(error);
+    onError(err) {
+        this.errorHandler(err);
+        return ResponseHelper.onError(err);
     }
+    // #endregion
     async GET(url, options) {
         const response = await this.axiosInstance.get(url, {
             params: options?.params,

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

@@ -9,7 +9,7 @@ import type { VerifyUserSecurity } from "../../types/banking/user/verifyUserSecu
 declare class UserService extends BaseService {
     protected endpoint: string;
     constructor(data: UserServiceParameters);
-    private userIdPath;
+    private userId;
     getUser(): Promise<import("../..").ApiResponse<UserData>>;
     getTermsAndConditions(): Promise<import("../..").ApiResponse<UserData>>;
     getSecurity(): Promise<import("../..").ApiResponse<UserData>>;

package/dist/api/service/user.js

@@ -14,88 +14,88 @@ class UserService extends BaseService {
             return req;
         });
     }
-    userIdPath() {
-        return `${this.context.getUserId()}`;
+    async userId() {
+        return await this.cookiesHelper.getUserId();
     }
     // #region "GET"
-    getUser() {
-        const url = this.resolveURL(`/${this.userIdPath()}`);
+    async getUser() {
+        const url = this.resolveURL(`/${await this.userId()}`);
         return this.GET(url);
     }
-    getTermsAndConditions() {
-        const url = this.resolveURL(`${UserEndpoints.TermsAndConditions}/${this.userIdPath()}`);
+    async getTermsAndConditions() {
+        const url = this.resolveURL(`${UserEndpoints.TermsAndConditions}/${await this.userId()}`);
         return this.GET(url);
     }
-    getSecurity() {
-        const url = this.resolveURL(`${UserEndpoints.Security}/${this.userIdPath()}`);
+    async getSecurity() {
+        const url = this.resolveURL(`${UserEndpoints.Security}/${await this.userId()}`);
         return this.GET(url);
     }
-    getPhone() {
-        const url = this.resolveURL(`${UserEndpoints.Phone}/${this.userIdPath()}`);
+    async getPhone() {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
         return this.GET(url);
     }
-    getPreferences() {
-        const url = this.resolveURL(`${UserEndpoints.Preferences}/${this.userIdPath()}`);
+    async getPreferences() {
+        const url = this.resolveURL(`${UserEndpoints.Preferences}/${await this.userId()}`);
         return this.GET(url);
     }
-    getPersonalInfo() {
-        const url = this.resolveURL(`${UserEndpoints.PersonalInfo}/${this.userIdPath()}`);
+    async getPersonalInfo() {
+        const url = this.resolveURL(`${UserEndpoints.PersonalInfo}/${await this.userId()}`);
         return this.GET(url);
     }
-    getLatestHistory() {
-        const url = this.resolveURL(`${UserEndpoints.HistoryLatest}/${this.userIdPath()}`);
+    async getLatestHistory() {
+        const url = this.resolveURL(`${UserEndpoints.HistoryLatest}/${await this.userId()}`);
         return this.GET(url);
     }
-    getIdentification() {
-        const url = this.resolveURL(`${UserEndpoints.Identification}/${this.userIdPath()}`);
+    async getIdentification() {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
         return this.GET(url, { flags: { showSensitiveData: true } });
     }
-    getHistory() {
-        const url = this.resolveURL(`${UserEndpoints.HistoryLatest}/${this.userIdPath()}`);
+    async getHistory() {
+        const url = this.resolveURL(`${UserEndpoints.HistoryLatest}/${await this.userId()}`);
         return this.GET(url);
     }
-    getGroup() {
-        const url = this.resolveURL(`${UserEndpoints.Group}/${this.userIdPath()}`);
+    async getGroup() {
+        const url = this.resolveURL(`${UserEndpoints.Group}/${await this.userId()}`);
         return this.GET(url);
     }
-    getExternalAuth() {
-        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${this.userIdPath()}`);
+    async getExternalAuth() {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
         return this.GET(url);
     }
-    getEmail() {
-        const url = this.resolveURL(`${UserEndpoints.Email}/${this.userIdPath()}`);
+    async getEmail() {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
         return this.GET(url);
     }
-    getDocuments() {
-        const url = this.resolveURL(`${UserEndpoints.Documents}/${this.userIdPath()}`);
+    async getDocuments() {
+        const url = this.resolveURL(`${UserEndpoints.Documents}/${await this.userId()}`);
         return this.GET(url);
     }
-    getCurrency() {
-        const url = this.resolveURL(`${UserEndpoints.Currency}/${this.userIdPath()}`);
+    async getCurrency() {
+        const url = this.resolveURL(`${UserEndpoints.Currency}/${await this.userId()}`);
         return this.GET(url);
     }
-    getCreditCard() {
-        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${this.userIdPath()}`);
+    async getCreditCard() {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
         return this.GET(url);
     }
-    getBankAccount() {
-        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${this.userIdPath()}`);
+    async getBankAccount() {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
         return this.GET(url, { flags: { showSensitiveData: true } });
     }
-    getAddress() {
-        const url = this.resolveURL(`${UserEndpoints.Address}/${this.userIdPath()}`);
+    async getAddress() {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
         return this.GET(url, { flags: { showSensitiveData: true } });
     }
-    getAccount() {
-        const url = this.resolveURL(`${UserEndpoints.Account}/${this.userIdPath()}`);
+    async getAccount() {
+        const url = this.resolveURL(`${UserEndpoints.Account}/${await this.userId()}`);
         return this.GET(url);
     }
-    getDeviceHistory() {
-        const url = this.resolveURL(`${UserEndpoints.DeviceHistory}/${this.userIdPath()}`);
+    async getDeviceHistory() {
+        const url = this.resolveURL(`${UserEndpoints.DeviceHistory}/${await this.userId()}`);
         return this.GET(url);
     }
-    getActivity() {
-        const url = this.resolveURL(`${UserEndpoints.Activity}/${this.userIdPath()}`);
+    async getActivity() {
+        const url = this.resolveURL(`${UserEndpoints.Activity}/${await this.userId()}`);
         return this.GET(url);
     }
     // #endregion
@@ -104,180 +104,180 @@ class UserService extends BaseService {
         const url = this.resolveURL();
         return this.POST(url, payload);
     }
-    createPhone(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Phone}/${this.userIdPath()}`);
+    async createPhone(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createDevice(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Device}/${this.userIdPath()}`);
+    async createDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Device}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createIdentification(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Identification}/${this.userIdPath()}`);
+    async createIdentification(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createExternalAuth(payload) {
-        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${this.userIdPath()}`);
+    async createExternalAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createEmail(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Email}/${this.userIdPath()}`);
+    async createEmail(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createCurrency(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Currency}/${this.userIdPath()}`);
+    async createCurrency(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Currency}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createCreditCard(payload) {
-        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${this.userIdPath()}`);
+    async createCreditCard(payload) {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createBankAccount(payload) {
-        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${this.userIdPath()}`);
+    async createBankAccount(payload) {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createAddress(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Address}/${this.userIdPath()}`);
+    async createAddress(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    createTicket(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Ticket}/${this.userIdPath()}`);
+    async createTicket(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Ticket}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    securityAccess(payload) {
-        const url = this.resolveURL(`${UserEndpoints.SecurityAccess}/${this.userIdPath()}`);
+    async securityAccess(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityAccess}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    uploadDocument(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Document}/${this.userIdPath()}`);
+    async uploadDocument(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Document}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    confirmSecurityData(payload) {
-        const url = this.resolveURL(`${UserEndpoints.SecurityConfirm}/${this.userIdPath()}`);
+    async confirmSecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityConfirm}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    validateSecurityData(payload) {
-        const url = this.resolveURL(`${UserEndpoints.SecurityValidate}/${this.userIdPath()}`);
+    async validateSecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityValidate}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    verifySecurityData(payload) {
-        const url = this.resolveURL(`${UserEndpoints.SecurityVerify}/${this.userIdPath()}`);
+    async verifySecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityVerify}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    resetSecurityData(payload) {
-        const url = this.resolveURL(`${UserEndpoints.SecurityReset}/${this.userIdPath()}`);
+    async resetSecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityReset}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    enrollGoogleAuth(payload) {
-        const url = this.resolveURL(`${UserEndpoints.AuthEnroll}/${this.userIdPath()}`);
+    async enrollGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthEnroll}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    activateGoogleAuth(payload) {
-        const url = this.resolveURL(`${UserEndpoints.AuthActivate}/${this.userIdPath()}`);
+    async activateGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthActivate}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    deactivateGoogleAuth(payload) {
-        const url = this.resolveURL(`${UserEndpoints.AuthDeactivate}/${this.userIdPath()}`);
+    async deactivateGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthDeactivate}/${await this.userId()}`);
         return this.POST(url, payload);
     }
-    deleteGoogleAuth(payload) {
-        const url = this.resolveURL(`${UserEndpoints.AuthDelete}/${this.userIdPath()}`);
+    async deleteGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthDelete}/${await this.userId()}`);
         return this.POST(url, payload);
     }
     // #endregion
     // #region "PUT"
-    updateUser(payload) {
-        const url = this.resolveURL(`/${this.userIdPath()}`);
+    async updateUser(payload) {
+        const url = this.resolveURL(`/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateSecurity(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Security}/${this.userIdPath()}`);
+    async updateSecurity(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Security}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updatePreferences(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Preferences}/${this.userIdPath()}`);
+    async updatePreferences(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Preferences}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateDevice(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Device}/${this.userIdPath()}`);
+    async updateDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Device}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    logoutDevice(payload) {
-        const url = this.resolveURL(`${UserEndpoints.DeviceLogout}/${this.userIdPath()}`);
+    async logoutDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.DeviceLogout}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updatePhone(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Phone}/${this.userIdPath()}`);
+    async updatePhone(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updatePersonalInfo(payload) {
-        const url = this.resolveURL(`${UserEndpoints.PersonalInfo}/${this.userIdPath()}`);
+    async updatePersonalInfo(payload) {
+        const url = this.resolveURL(`${UserEndpoints.PersonalInfo}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateIdentification(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Identification}/${this.userIdPath()}`);
+    async updateIdentification(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateExternalAuth(payload) {
-        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${this.userIdPath()}`);
+    async updateExternalAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateEmail(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Email}/${this.userIdPath()}`);
+    async updateEmail(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateCreditCard(payload) {
-        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${this.userIdPath()}`);
+    async updateCreditCard(payload) {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateBankAccount(payload) {
-        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${this.userIdPath()}`);
+    async updateBankAccount(payload) {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateAddress(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Address}/${this.userIdPath()}`);
+    async updateAddress(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
-    updateUserType(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Type}/${this.userIdPath()}`);
+    async updateUserType(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Type}/${await this.userId()}`);
         return this.PUT(url, payload);
     }
     // #endregion
     // #region "DELETE"
-    deleteUser() {
-        const url = this.resolveURL(`/${this.userIdPath()}`);
+    async deleteUser() {
+        const url = this.resolveURL(`/${await this.userId()}`);
         return this.DELETE(url);
     }
-    deleteCreditCard() {
-        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${this.userIdPath()}`);
+    async deleteCreditCard() {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
         return this.DELETE(url);
     }
-    deleteAddress(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Address}/${this.userIdPath()}`);
+    async deleteAddress(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
         return this.DELETE(url, payload);
     }
-    deleteDevice(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Device}/${this.userIdPath()}`);
+    async deleteDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Device}/${await this.userId()}`);
         return this.DELETE(url, payload);
     }
-    deleteBankAccount(payload) {
-        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${this.userIdPath()}`);
+    async deleteBankAccount(payload) {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
         return this.DELETE(url, payload);
     }
-    deleteIdentification(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Identification}/${this.userIdPath()}`);
+    async deleteIdentification(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
         return this.DELETE(url, payload);
     }
-    deleteEmail(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Email}/${this.userIdPath()}`);
+    async deleteEmail(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
         return this.DELETE(url, payload);
     }
-    deletePhone(payload) {
-        const url = this.resolveURL(`${UserEndpoints.Phone}/${this.userIdPath()}`);
+    async deletePhone(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
         return this.DELETE(url, payload);
     }
-    deleteExternalAuth() {
-        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${this.userIdPath()}`);
+    async deleteExternalAuth() {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
         return this.DELETE(url);
     }
 }

package/dist/helper/api/axiosHelper.js

@@ -41,11 +41,11 @@ class AxiosHelper {
             config.headers = {};
         config.headers[key] = value;
     };
-    static injectBaseHeaders = (req, context, endpoint) => {
-        const token = context.getToken();
-        const userId = context.getUserId();
+    static injectBaseHeaders = async (req, context, cookiesHelper, endpoint) => {
+        const token = await cookiesHelper.getAccessToken();
+        const userId = await cookiesHelper.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/helper/storage/cookiesHelper.d.ts

@@ -36,6 +36,8 @@ declare class CookiesHelper {
     getDEK(): Promise<string>;
     setDEK(deviceEncryptionKey: string, USR: USR): Promise<void>;
     validateDEK(DEK: string): Promise<boolean>;
+    getUserId(): Promise<number>;
+    getDeviceId(): Promise<number>;
     getUSR(): Promise<USR | null>;
     setUSR(deviceId: string, userId: string): Promise<void>;
     validateUSR(USR: string): Promise<boolean>;

package/dist/helper/storage/cookiesHelper.js

@@ -218,6 +218,28 @@ class CookiesHelper {
         }
     }
     // #endregion
+    // #region "User ID / Device ID"
+    async getUserId() {
+        try {
+            const USR = await this.getUSR();
+            return Number(USR?.user_id || 0);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return 0;
+        }
+    }
+    async getDeviceId() {
+        try {
+            const USR = await this.getUSR();
+            return Number(USR?.device_id || 0);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return 0;
+        }
+    }
+    // #endregion
     // #region "USR"
     async getUSR() {
         try {

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

@@ -22,11 +22,5 @@ interface ClientContextProvider {
     getProgramId(): number;
     getLang(): string;
     setLang(lang: string): void;
-    getInstallationId(): string;
-    setInstallationId(installationId: string): void;
-    getToken(): string;
-    setToken(token: string): void;
-    getUserId(): number;
-    setUserId(userId: number): void;
 }
 export type { InitialContext, ClientContextProvider };

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.7",
+  "version": "0.4.9",
   "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 };