ggez-banking-sdk 0.1.178 → 0.1.179

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

@@ -1,8 +1,8 @@
-import type { AccountClientData } from "../../types";
-declare class AccountClient {
-    private readonly clientData;
+import type { AccountClientData, ErrorHandler } from "../../types";
+import { BaseClient } from "./base";
+declare class AccountClient extends BaseClient {
     private accountService;
-    constructor(clientData: AccountClientData);
+    constructor(clientData: AccountClientData, errorHandler: ErrorHandler);
     Get: (accountId: number) => Promise<{
         data: import("../../types").AccountData;
         success: boolean;

package/dist/api/clients/account.js

@@ -1,37 +1,36 @@
 import { AxiosHelper } from "../../helper";
-import { ResponseHelper } from "../../helper";
 import { FillAccountData, FillResultByError } from "../data";
 import { AccountService } from "../services";
-class AccountClient {
-    clientData;
+import { BaseClient } from "./base";
+class AccountClient extends BaseClient {
     accountService;
-    constructor(clientData) {
-        this.clientData = clientData;
-        const { token, baseUrl, lang, installationId, userId } = clientData;
+    constructor(clientData, errorHandler) {
+        super(clientData, errorHandler);
+        const { token, baseUrl, lang, installationId, userId } = this.clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
-        this.accountService = new AccountService({ config, userId });
+        this.accountService = new AccountService({ config, userId }, errorHandler);
     }
     // #region "GET"
     Get = async (accountId) => {
         try {
             const response = await this.accountService.get(accountId);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const accountData = FillAccountData("result", result);
-            return ResponseHelper.GetErrorResponse(accountData, "Get");
+            return this.responseHelper.GetErrorResponse(accountData, "Get");
         }
     };
     GetLimits = async (accountId) => {
         try {
             const response = await this.accountService.getLimits(accountId);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const accountData = FillAccountData("result", result);
-            return ResponseHelper.GetErrorResponse(accountData, "GetLimits");
+            return this.responseHelper.GetErrorResponse(accountData, "GetLimits");
         }
     };
 }

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

@@ -1,9 +1,9 @@
-import type { AuthClientData, IGenerateLimitedTokenData, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
-declare class AuthClient {
-    private readonly clientData;
+import type { AuthClientData, ErrorHandler, IGenerateLimitedTokenData, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
+import { BaseClient } from "./base";
+declare class AuthClient extends BaseClient {
     private programId;
     private authService;
-    constructor(clientData: AuthClientData);
+    constructor(clientData: AuthClientData, errorHandler: ErrorHandler);
     LoginUserCredentials: (data: ILoginUserCredentialsData) => Promise<{
         data: import("../../types").TokenData;
         success: boolean;

package/dist/api/clients/auth.js

@@ -1,16 +1,15 @@
 import { AxiosHelper } from "../../helper";
-import { ResponseHelper } from "../../helper";
 import { FillGenerateLimitedTokenData, FillLoginDeviceCredentialsData, FillLoginGoogleCredentialsData, FillLoginUserCredentialsData, FillResult, FillResultByError, FillTokenData, } from "../data";
 import { AuthService } from "../services";
-class AuthClient {
-    clientData;
+import { BaseClient } from "./base";
+class AuthClient extends BaseClient {
     programId;
     authService;
-    constructor(clientData) {
-        this.clientData = clientData;
+    constructor(clientData, errorHandler) {
+        super(clientData, errorHandler);
         const { baseUrl, nodeUrl, lang, programId, userId } = this.clientData;
         const config = AxiosHelper.GetAuthAxiosConfig(baseUrl, lang, "");
-        this.authService = new AuthService({ config, nodeUrl, userId });
+        this.authService = new AuthService({ config, nodeUrl, userId }, this.errorHandler);
         this.programId = programId;
     }
     // #region "POST"
@@ -19,12 +18,12 @@ class AuthClient {
             const credentialsData = FillLoginUserCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData);
             response.data.result = FillResult(response.data);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = FillTokenData("result", result);
-            return ResponseHelper.GetErrorResponse(tokenData, "LoginUserCredentials");
+            return this.responseHelper.GetErrorResponse(tokenData, "LoginUserCredentials");
         }
     };
     LoginDeviceCredentials = async (data) => {
@@ -32,12 +31,12 @@ class AuthClient {
             const credentialsData = FillLoginDeviceCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData);
             response.data.result = FillResult(response.data);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = FillTokenData("result", result);
-            return ResponseHelper.GetErrorResponse(tokenData, "LoginDeviceCredentials");
+            return this.responseHelper.GetErrorResponse(tokenData, "LoginDeviceCredentials");
         }
     };
     LoginGoogleCredentials = async (data) => {
@@ -45,12 +44,12 @@ class AuthClient {
             const credentialsData = FillLoginGoogleCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData);
             response.data.result = FillResult(response.data);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = FillTokenData("result", result);
-            return ResponseHelper.GetErrorResponse(tokenData, "LoginGoogleCredentials");
+            return this.responseHelper.GetErrorResponse(tokenData, "LoginGoogleCredentials");
         }
     };
     GenerateLimitedToken = async (data) => {
@@ -58,12 +57,12 @@ class AuthClient {
             const tokenData = FillGenerateLimitedTokenData(data);
             const response = await this.authService.generateLimitedToken(tokenData);
             response.data.result = FillResult(response.data);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = FillTokenData("result", result);
-            return ResponseHelper.GetErrorResponse(tokenData, "GenerateLimitedToken");
+            return this.responseHelper.GetErrorResponse(tokenData, "GenerateLimitedToken");
         }
     };
 }

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

@@ -0,0 +1,8 @@
+import { ErrorHandler, ResponseHelper } from "../..";
+declare abstract class BaseClient {
+    protected clientData: any;
+    protected errorHandler: (error: any) => void;
+    protected responseHelper: ResponseHelper;
+    constructor(clientData: any, errorHandler: ErrorHandler);
+}
+export { BaseClient };

package/dist/api/clients/base.js

@@ -0,0 +1,12 @@
+import { ResponseHelper } from "../..";
+class BaseClient {
+    clientData;
+    errorHandler;
+    responseHelper;
+    constructor(clientData, errorHandler) {
+        this.clientData = clientData;
+        this.errorHandler = errorHandler;
+        this.responseHelper = new ResponseHelper(errorHandler);
+    }
+}
+export { BaseClient };

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

@@ -1,28 +1,28 @@
-import type { BlockchainClientData, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types/api";
-declare class BlockchainClient {
-    private readonly clientData;
+import type { BlockchainClientData, ErrorHandler, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types";
+import { BaseClient } from "./base";
+declare class BlockchainClient extends BaseClient {
     private blockchainService;
-    constructor(clientData: BlockchainClientData);
+    constructor(clientData: BlockchainClientData, errorHandler: ErrorHandler);
     Send: (data: IBlockchainSendRequestData) => Promise<{
-        data: import("../..").BlockchainData;
+        data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;
     }>;
     MultiSend: (data: IBlockchainMultiSendRequestData) => Promise<{
-        data: import("../..").BlockchainData;
+        data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;
     }>;
     Delegate: (data: IBlockchainDelegateRequestData) => Promise<{
-        data: import("../..").BlockchainData;
+        data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;
     }>;
     Undelegate: (data: IBlockchainUndelegateRequestData) => Promise<{
-        data: import("../..").BlockchainData;
+        data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;

package/dist/api/clients/blockchain.js

@@ -1,63 +1,62 @@
 import { AxiosHelper } from "../../helper";
-import { ResponseHelper } from "../../helper";
 import { FillBlockchainData, FillBlockchainDelegateData, FillBlockchainMultiSendData, FillBlockchainSendData, FillBlockchainUndelegateData, FillResultByError, } from "../data";
-import { BlockchainService } from "../services/blockchain";
-class BlockchainClient {
-    clientData;
+import { BlockchainService } from "../services";
+import { BaseClient } from "./base";
+class BlockchainClient extends BaseClient {
     blockchainService;
-    constructor(clientData) {
-        this.clientData = clientData;
+    constructor(clientData, errorHandler) {
+        super(clientData, errorHandler);
         const { token, baseUrl, lang, installationId, userId } = clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
-        this.blockchainService = new BlockchainService({ config, userId });
+        this.blockchainService = new BlockchainService({ config, userId }, this.errorHandler);
     }
     // #region "POST"
     Send = async (data) => {
         try {
             const blockchainSendData = FillBlockchainSendData(data);
             const response = await this.blockchainService.send(blockchainSendData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = FillBlockchainData("result", result);
-            return ResponseHelper.GetErrorResponse(blockchainData, "Send");
+            return this.responseHelper.GetErrorResponse(blockchainData, "Send");
         }
     };
     MultiSend = async (data) => {
         try {
             const blockchainMultiSendData = FillBlockchainMultiSendData(data);
             const response = await this.blockchainService.multiSend(blockchainMultiSendData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = FillBlockchainData("result", result);
-            return ResponseHelper.GetErrorResponse(blockchainData, "MultiSend");
+            return this.responseHelper.GetErrorResponse(blockchainData, "MultiSend");
         }
     };
     Delegate = async (data) => {
         try {
             const blockchainDelegateData = FillBlockchainDelegateData(data);
             const response = await this.blockchainService.delegate(blockchainDelegateData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = FillBlockchainData("result", result);
-            return ResponseHelper.GetErrorResponse(blockchainData, "Delegate");
+            return this.responseHelper.GetErrorResponse(blockchainData, "Delegate");
         }
     };
     Undelegate = async (data) => {
         try {
             const blockchainUndelegateData = FillBlockchainUndelegateData(data);
             const response = await this.blockchainService.undelegate(blockchainUndelegateData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = FillBlockchainData("result", result);
-            return ResponseHelper.GetErrorResponse(blockchainData, "Undelegate");
+            return this.responseHelper.GetErrorResponse(blockchainData, "Undelegate");
         }
     };
 }

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

@@ -1,13 +1,23 @@
-import { IPAddressAndLocationClientData } from "../../types";
-declare class IPAddressAndLocationClient {
-    private readonly clientData;
+import { ErrorHandler, IPAddressAndLocationClientData } from "../../types";
+import { BaseClient } from "./base";
+declare class IPAddressAndLocationClient extends BaseClient {
     private ipAddressAndLocationService;
-    constructor(clientData: IPAddressAndLocationClientData);
-    GetGeoCoordinates: () => Promise<import("../../types").GeoCoordinates>;
-    GetIPAddress: () => Promise<string>;
+    constructor(clientData: IPAddressAndLocationClientData, errorHandler: ErrorHandler);
+    GetGeoCoordinates: () => Promise<import("../../types").GeoCoordinates> | {
+        latitude: number;
+        longitude: number;
+        position_description: string;
+    };
+    GetIPAddress: () => Promise<string> | "";
     GetGeoCoordinatesAndIPAddress: () => Promise<{
         geo_coordinates: import("../../types").GeoCoordinates;
         ip_address: string;
-    }>;
+    }> | {
+        geo_coordinates: {
+            latitude: number;
+            longitude: number;
+        };
+        ip_address: string;
+    };
 }
 export { IPAddressAndLocationClient };

package/dist/api/clients/ipAddressAndLocation.js

@@ -1,29 +1,41 @@
 import { IPAddressAndLocationService } from "../services";
 import { AxiosHelper, GeoHelper } from "../../helper";
-class IPAddressAndLocationClient {
-    clientData;
+import { BaseClient } from "./base";
+class IPAddressAndLocationClient extends BaseClient {
     ipAddressAndLocationService;
-    constructor(clientData) {
-        this.clientData = clientData;
+    constructor(clientData, errorHandler) {
+        super(clientData, errorHandler);
         const { token, baseUrl, lang, installationId, userId } = clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
         this.ipAddressAndLocationService = new IPAddressAndLocationService({
             config,
             userId,
-        });
+        }, this.errorHandler);
     }
     // #region "GET"
-    GetGeoCoordinates = async () => {
-        const data = await GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
-        return data;
+    GetGeoCoordinates = () => {
+        try {
+            return GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
+        }
+        catch (error) {
+            return { latitude: 0, longitude: 0, position_description: "N/A, N/A" };
+        }
     };
-    GetIPAddress = async () => {
-        const data = await GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
-        return data;
+    GetIPAddress = () => {
+        try {
+            return GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
+        }
+        catch (error) {
+            return "";
+        }
     };
-    GetGeoCoordinatesAndIPAddress = async () => {
-        const data = await GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
-        return data;
+    GetGeoCoordinatesAndIPAddress = () => {
+        try {
+            return GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
+        }
+        catch (error) {
+            return { geo_coordinates: { latitude: 0, longitude: 0 }, ip_address: "" };
+        }
     };
 }
 export { IPAddressAndLocationClient };

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

@@ -1,8 +1,8 @@
-import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, LimitedClientData, IValidateForgetPasswordData, IConfirmForgetPasswordData } from "../../types";
-declare class LimitedClient {
-    private readonly clientData;
+import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, LimitedClientData, IValidateForgetPasswordData, IConfirmForgetPasswordData, ErrorHandler } from "../../types";
+import { BaseClient } from "./base";
+declare class LimitedClient extends BaseClient {
     private limitedService;
-    constructor(clientData: LimitedClientData);
+    constructor(clientData: LimitedClientData, errorHandler: ErrorHandler);
     ValidateForgetPassword: (data: IValidateForgetPasswordData) => Promise<{
         data: import("../../types").ForgetSecurityData;
         success: boolean;

package/dist/api/clients/limited.js

@@ -1,115 +1,114 @@
 import { AxiosHelper } from "../../helper";
-import { ResponseHelper } from "../../helper";
 import { FillConfirmEmailData, FillConfirmForgetPasswordData, FillConfirmPhoneData, FillConfirmUserSecurityData, FillForgetSecurityData, FillResultByError, FillValidateEmailData, FillValidateForgetPasswordData, FillValidateLimitedSecurityData, FillValidatePhoneData, FillVerifyEmailData, FillVerifyPhoneData, FillVerifyUserSecurityData, } from "../data";
 import { LimitedService } from "../services";
-class LimitedClient {
-    clientData;
+import { BaseClient } from "./base";
+class LimitedClient extends BaseClient {
     limitedService;
-    constructor(clientData) {
-        this.clientData = clientData;
+    constructor(clientData, errorHandler) {
+        super(clientData, errorHandler);
         const { token, baseUrl, nodeUrl, lang, userId } = this.clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang);
         this.limitedService = new LimitedService({
             config,
             nodeUrl,
             userId,
-        });
+        }, this.errorHandler);
     }
     // #region "POST"
     ValidateForgetPassword = async (data) => {
         try {
             const forgetSecurityData = FillValidateForgetPasswordData(data);
             const response = await this.limitedService.validateForgetSecurityData(forgetSecurityData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = FillForgetSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(forgetSecurityData, "ValidateForgetPassword");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ValidateForgetPassword");
         }
     };
     ConfirmForgetPassword = async (data) => {
         try {
             const forgetSecurityData = FillConfirmForgetPasswordData(data);
             const response = await this.limitedService.confirmForgetSecurityData(forgetSecurityData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = FillForgetSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(forgetSecurityData, "ConfirmForgetPassword");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ConfirmForgetPassword");
         }
     };
     ValidateEmail = async (data) => {
         try {
             const validateLimitedSecurity = FillValidateEmailData(data);
             const response = await this.limitedService.validateSecurityData(validateLimitedSecurity);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = FillValidateLimitedSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(forgetSecurityData, "ConfirmForgetPassword");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ConfirmForgetPassword");
         }
     };
     ValidatePhone = async (data) => {
         try {
             const validateLimitedSecurity = FillValidatePhoneData(data);
             const response = await this.limitedService.validateSecurityData(validateLimitedSecurity);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = FillValidateLimitedSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(forgetSecurityData, "ValidatePhone");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ValidatePhone");
         }
     };
     VerifyEmail = async (data) => {
         try {
             const verifyUserSecurity = FillVerifyEmailData(data);
             const response = await this.limitedService.verifySecurityData(verifyUserSecurity);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const verifySecurityData = FillVerifyUserSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(verifySecurityData, "VerifyEmail");
+            return this.responseHelper.GetErrorResponse(verifySecurityData, "VerifyEmail");
         }
     };
     VerifyPhone = async (data) => {
         try {
             const verifyUserSecurity = FillVerifyPhoneData(data);
             const response = await this.limitedService.verifySecurityData(verifyUserSecurity);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const verifySecurityData = FillVerifyUserSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(verifySecurityData, "VerifyPhone");
+            return this.responseHelper.GetErrorResponse(verifySecurityData, "VerifyPhone");
         }
     };
     ConfirmEmail = async (data) => {
         try {
             const confirmUserSecurity = FillConfirmEmailData(data);
             const response = await this.limitedService.confirmSecurityData(confirmUserSecurity);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const confirmUserSecurity = FillConfirmUserSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(confirmUserSecurity, "ConfirmEmail");
+            return this.responseHelper.GetErrorResponse(confirmUserSecurity, "ConfirmEmail");
         }
     };
     ConfirmPhone = async (data) => {
         try {
             const confirmUserSecurity = FillConfirmPhoneData(data);
             const response = await this.limitedService.confirmSecurityData(confirmUserSecurity);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const confirmUserSecurity = FillConfirmUserSecurityData("result", result);
-            return ResponseHelper.GetErrorResponse(confirmUserSecurity, "ConfirmPhone");
+            return this.responseHelper.GetErrorResponse(confirmUserSecurity, "ConfirmPhone");
         }
     };
 }

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

@@ -1,8 +1,8 @@
-import { ICreateOrderData, OrderClientData } from "../../types";
-declare class OrderClient {
-    private readonly clientData;
+import { ErrorHandler, ICreateOrderData, OrderClientData } from "../../types";
+import { BaseClient } from "./base";
+declare class OrderClient extends BaseClient {
     private orderService;
-    constructor(clientData: OrderClientData);
+    constructor(clientData: OrderClientData, errorHandler: ErrorHandler);
     CreateOrder: (data: ICreateOrderData) => Promise<{
         data: import("../../types").OrderData;
         success: boolean;

package/dist/api/clients/order.js

@@ -1,27 +1,26 @@
 import { AxiosHelper } from "../../helper";
-import { ResponseHelper } from "../../helper";
 import { FillCreateOrderData, FillOrderData, FillResultByError } from "../data";
 import { OrderService } from "../services";
-class OrderClient {
-    clientData;
+import { BaseClient } from "./base";
+class OrderClient extends BaseClient {
     orderService;
-    constructor(clientData) {
-        this.clientData = clientData;
+    constructor(clientData, errorHandler) {
+        super(clientData, errorHandler);
         const { token, baseUrl, lang, installationId, userId } = clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
-        this.orderService = new OrderService({ config, userId });
+        this.orderService = new OrderService({ config, userId }, this.errorHandler);
     }
     // #region "POST"
     CreateOrder = async (data) => {
         try {
             const createOrderData = FillCreateOrderData(data);
             const response = await this.orderService.create(createOrderData);
-            return ResponseHelper.GetResponse(response.data);
+            return this.responseHelper.GetResponse(response.data);
         }
         catch (error) {
             const result = FillResultByError(error);
             const orderData = FillOrderData("result", result);
-            return ResponseHelper.GetErrorResponse(orderData, "CreateOrder");
+            return this.responseHelper.GetErrorResponse(orderData, "CreateOrder");
         }
     };
 }

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

@@ -1,10 +1,10 @@
-import type { OrganizationClientData } from "../../types";
+import type { ErrorHandler, OrganizationClientData } from "../../types";
 import type { ICreateOrganizationData, IUpdateOrganizationData, IUploadOrganizationDocumentData } from "../../types";
-declare class OrganizationClient {
-    private readonly clientData;
+import { BaseClient } from "./base";
+declare class OrganizationClient extends BaseClient {
     private organizationService;
     private userId;
-    constructor(clientData: OrganizationClientData);
+    constructor(clientData: OrganizationClientData, errorHandler: ErrorHandler);
     CreateOrganization: (data: ICreateOrganizationData) => Promise<{
         data: import("../../types").OrganizationData;
         success: boolean;