ggez-banking-sdk 0.3.25 → 0.3.27

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

@@ -8,13 +8,23 @@ declare class AccountClient extends BaseClient {
         data: import("../..").AccountData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").AccountData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     getLimits: (accountId: number, options?: RequestOptions) => Promise<{
         data: import("../..").AccountData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").AccountData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
 }
 export { AccountClient };

package/dist/api/clients/account.js

@@ -1,5 +1,5 @@
 import { AxiosHelper } from "../../helper/api/axiosHelper";
-import { CreateDefaultAccountData, FillResultByError } from "../data";
+import { createDefaultAccountData, fillResultByError } from "../data";
 import { AccountService } from "../services";
 import { BaseClient } from "./base";
 class AccountClient extends BaseClient {
@@ -7,30 +7,30 @@ class AccountClient extends BaseClient {
     constructor(clientData, errorHandler) {
         super(clientData, errorHandler);
         const { token, baseUrl, lang, installationId, userId } = this.clientData;
-        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        const config = AxiosHelper.getAxiosConfig(token, baseUrl, lang, installationId);
         this.accountService = new AccountService({ config, userId });
     }
     // #region "GET"
     get = async (accountId, options) => {
         try {
             const response = await this.accountService.get(accountId, options);
-            return this.responseHelper.GetResponse(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const accountData = CreateDefaultAccountData({ result });
-            return this.responseHelper.GetErrorResponse(accountData, "get");
+            const result = fillResultByError(error);
+            const accountData = createDefaultAccountData({ result });
+            return this.responseHelper.getErrorResponse(accountData, "get");
         }
     };
     getLimits = async (accountId, options) => {
         try {
             const response = await this.accountService.getLimits(accountId, options);
-            return this.responseHelper.GetResponse(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const accountData = CreateDefaultAccountData({ result });
-            return this.responseHelper.GetErrorResponse(accountData, "getLimits");
+            const result = fillResultByError(error);
+            const accountData = createDefaultAccountData({ result });
+            return this.responseHelper.getErrorResponse(accountData, "getLimits");
         }
     };
 }

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

@@ -5,33 +5,48 @@ declare class AuthClient extends BaseClient {
     private authService;
     constructor(clientData: AuthClientData, errorHandler: ErrorHandler);
     loginUserCredentials: (data: ILoginUserCredentialsData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TokenData;
+        data: import("../..").TokenData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").TokenData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     loginDeviceCredentials: (data: ILoginDeviceCredentialsData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TokenData;
+        data: import("../..").TokenData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").TokenData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     loginGoogleCredentials: (data: ILoginGoogleCredentialsData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TokenData;
+        data: import("../..").TokenData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").TokenData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     generateLimitedToken: (data: IGenerateLimitedTokenData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TokenData;
+        data: import("../..").TokenData;
         success: boolean;
         message: string;
         error: string;
     } | {
-        data: import("../../types").NodeTokenData;
+        data: import("../..").NodeTokenData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
     }>;
 }
 export { AuthClient };

package/dist/api/clients/auth.js

@@ -1,5 +1,5 @@
 import { AxiosHelper } from "../../helper/api/axiosHelper";
-import { FillGenerateLimitedTokenData, FillLoginDeviceCredentialsData, FillLoginGoogleCredentialsData, FillLoginUserCredentialsData, FillResult, FillResultByError, CreateDefaultTokenData, } from "../data";
+import { fillGenerateLimitedTokenData, fillLoginDeviceCredentialsData, fillLoginGoogleCredentialsData, fillLoginUserCredentialsData, fillResult, fillResultByError, createDefaultTokenData, } from "../data";
 import { AuthService } from "../services";
 import { BaseClient } from "./base";
 class AuthClient extends BaseClient {
@@ -8,61 +8,61 @@ class AuthClient extends BaseClient {
     constructor(clientData, errorHandler) {
         super(clientData, errorHandler);
         const { baseUrl, nodeUrl, lang, programId, userId } = this.clientData;
-        const config = AxiosHelper.GetAuthAxiosConfig(baseUrl, lang, "");
+        const config = AxiosHelper.getAuthAxiosConfig(baseUrl, lang, "");
         this.authService = new AuthService({ config, nodeUrl, userId });
         this.programId = programId;
     }
     // #region "POST"
     loginUserCredentials = async (data, options) => {
         try {
-            const credentialsData = FillLoginUserCredentialsData(this.programId, data);
+            const credentialsData = fillLoginUserCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData, options);
-            response.data.result = FillResult(response.data);
-            return this.responseHelper.GetResponse(response.data);
+            response.data.result = fillResult(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "loginUserCredentials");
+            const result = fillResultByError(error);
+            const tokenData = createDefaultTokenData({ result });
+            return this.responseHelper.getErrorResponse(tokenData, "loginUserCredentials");
         }
     };
     loginDeviceCredentials = async (data, options) => {
         try {
-            const credentialsData = FillLoginDeviceCredentialsData(this.programId, data);
+            const credentialsData = fillLoginDeviceCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData, options);
-            response.data.result = FillResult(response.data);
-            return this.responseHelper.GetResponse(response.data);
+            response.data.result = fillResult(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "loginDeviceCredentials");
+            const result = fillResultByError(error);
+            const tokenData = createDefaultTokenData({ result });
+            return this.responseHelper.getErrorResponse(tokenData, "loginDeviceCredentials");
         }
     };
     loginGoogleCredentials = async (data, options) => {
         try {
-            const credentialsData = FillLoginGoogleCredentialsData(this.programId, data);
+            const credentialsData = fillLoginGoogleCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData, options);
-            response.data.result = FillResult(response.data);
-            return this.responseHelper.GetResponse(response.data);
+            response.data.result = fillResult(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "loginGoogleCredentials");
+            const result = fillResultByError(error);
+            const tokenData = createDefaultTokenData({ result });
+            return this.responseHelper.getErrorResponse(tokenData, "loginGoogleCredentials");
         }
     };
     generateLimitedToken = async (data, options) => {
         try {
-            const tokenData = FillGenerateLimitedTokenData(data);
+            const tokenData = fillGenerateLimitedTokenData(data);
             const response = await this.authService.generateLimitedToken(tokenData, options);
-            response.data.result = FillResult(response.data);
-            return this.responseHelper.GetResponse(response.data);
+            response.data.result = fillResult(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "generateLimitedToken");
+            const result = fillResultByError(error);
+            const tokenData = createDefaultTokenData({ result });
+            return this.responseHelper.getErrorResponse(tokenData, "generateLimitedToken");
         }
     };
 }

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

@@ -4,28 +4,48 @@ declare class BlockchainClient extends BaseClient {
     private blockchainService;
     constructor(clientData: BlockchainClientData, errorHandler: ErrorHandler);
     send: (data: IBlockchainSendRequestData, options?: RequestOptions) => Promise<{
-        data: import("../../types").BlockchainData;
+        data: import("../..").BlockchainData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     multiSend: (data: IBlockchainMultiSendRequestData, options?: RequestOptions) => Promise<{
-        data: import("../../types").BlockchainData;
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").BlockchainData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     delegate: (data: IBlockchainDelegateRequestData, options?: RequestOptions) => Promise<{
-        data: import("../../types").BlockchainData;
+        data: import("../..").BlockchainData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     undelegate: (data: IBlockchainUndelegateRequestData, options?: RequestOptions) => Promise<{
-        data: import("../../types").BlockchainData;
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").BlockchainData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
 }
 export { BlockchainClient };

package/dist/api/clients/blockchain.js

@@ -1,5 +1,5 @@
 import { AxiosHelper } from "../../helper/api/axiosHelper";
-import { CreateDefaultBlockchainData, FillBlockchainDelegateData, FillBlockchainMultiSendData, FillBlockchainSendData, FillBlockchainUndelegateData, FillResultByError, } from "../data";
+import { createDefaultBlockchainData, fillBlockchainDelegateData, fillBlockchainMultiSendData, fillBlockchainSendData, fillBlockchainUndelegateData, fillResultByError, } from "../data";
 import { BlockchainService } from "../services";
 import { BaseClient } from "./base";
 class BlockchainClient extends BaseClient {
@@ -7,56 +7,56 @@ class BlockchainClient extends BaseClient {
     constructor(clientData, errorHandler) {
         super(clientData, errorHandler);
         const { token, baseUrl, lang, installationId, userId } = clientData;
-        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        const config = AxiosHelper.getAxiosConfig(token, baseUrl, lang, installationId);
         this.blockchainService = new BlockchainService({ config, userId });
     }
     // #region "POST"
     send = async (data, options) => {
         try {
-            const blockchainSendData = FillBlockchainSendData(data);
+            const blockchainSendData = fillBlockchainSendData(data);
             const response = await this.blockchainService.send(blockchainSendData, options);
-            return this.responseHelper.GetResponse(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "send");
+            const result = fillResultByError(error);
+            const blockchainData = createDefaultBlockchainData({ result });
+            return this.responseHelper.getErrorResponse(blockchainData, "send");
         }
     };
     multiSend = async (data, options) => {
         try {
-            const blockchainMultiSendData = FillBlockchainMultiSendData(data);
+            const blockchainMultiSendData = fillBlockchainMultiSendData(data);
             const response = await this.blockchainService.multiSend(blockchainMultiSendData, options);
-            return this.responseHelper.GetResponse(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "multiSend");
+            const result = fillResultByError(error);
+            const blockchainData = createDefaultBlockchainData({ result });
+            return this.responseHelper.getErrorResponse(blockchainData, "multiSend");
         }
     };
     delegate = async (data, options) => {
         try {
-            const blockchainDelegateData = FillBlockchainDelegateData(data);
+            const blockchainDelegateData = fillBlockchainDelegateData(data);
             const response = await this.blockchainService.delegate(blockchainDelegateData, options);
-            return this.responseHelper.GetResponse(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "delegate");
+            const result = fillResultByError(error);
+            const blockchainData = createDefaultBlockchainData({ result });
+            return this.responseHelper.getErrorResponse(blockchainData, "delegate");
         }
     };
     undelegate = async (data, options) => {
         try {
-            const blockchainUndelegateData = FillBlockchainUndelegateData(data);
+            const blockchainUndelegateData = fillBlockchainUndelegateData(data);
             const response = await this.blockchainService.undelegate(blockchainUndelegateData, options);
-            return this.responseHelper.GetResponse(response.data);
+            return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
-            const result = FillResultByError(error);
-            const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "undelegate");
+            const result = fillResultByError(error);
+            const blockchainData = createDefaultBlockchainData({ result });
+            return this.responseHelper.getErrorResponse(blockchainData, "undelegate");
         }
     };
 }

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

@@ -3,14 +3,14 @@ import { BaseClient } from "./base";
 declare class IPAddressAndLocationClient extends BaseClient {
     private ipAddressAndLocationService;
     constructor(clientData: IPAddressAndLocationClientData, errorHandler: ErrorHandler);
-    getGeoCoordinates: () => Promise<import("../../types").GeoCoordinates> | {
+    getGeoCoordinates: () => Promise<import("../..").GeoCoordinates> | {
         latitude: number;
         longitude: number;
         position_description: string;
     };
     getIPAddress: () => Promise<string> | "";
     getGeoCoordinatesAndIPAddress: () => Promise<{
-        geo_coordinates: import("../../types").GeoCoordinates;
+        geo_coordinates: import("../..").GeoCoordinates;
         ip_address: string;
     }> | {
         geo_coordinates: {

package/dist/api/clients/ipAddressAndLocation.js

@@ -7,7 +7,7 @@ class IPAddressAndLocationClient extends BaseClient {
     constructor(clientData, errorHandler) {
         super(clientData, errorHandler);
         const { token, baseUrl, lang, installationId, userId } = clientData;
-        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        const config = AxiosHelper.getAxiosConfig(token, baseUrl, lang, installationId);
         this.ipAddressAndLocationService = new IPAddressAndLocationService({
             config,
             userId,
@@ -16,7 +16,7 @@ class IPAddressAndLocationClient extends BaseClient {
     // #region "GET"
     getGeoCoordinates = () => {
         try {
-            return GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
+            return GeoHelper.getGeoCoordinates(this.ipAddressAndLocationService);
         }
         catch (error) {
             return { latitude: 0, longitude: 0, position_description: "N/A, N/A" };
@@ -24,7 +24,7 @@ class IPAddressAndLocationClient extends BaseClient {
     };
     getIPAddress = () => {
         try {
-            return GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
+            return GeoHelper.getIPAddress(this.ipAddressAndLocationService);
         }
         catch (error) {
             return "";
@@ -32,7 +32,7 @@ class IPAddressAndLocationClient extends BaseClient {
     };
     getGeoCoordinatesAndIPAddress = () => {
         try {
-            return GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
+            return GeoHelper.getGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
         }
         catch (error) {
             return { geo_coordinates: { latitude: 0, longitude: 0 }, ip_address: "" };

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

@@ -4,58 +4,103 @@ declare class LimitedClient extends BaseClient {
     private limitedService;
     constructor(clientData: LimitedClientData, errorHandler: ErrorHandler);
     checkForgetPassword: (data: ICheckForgetPasswordData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ForgetSecurityData;
+        data: import("../..").ForgetSecurityData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").ForgetSecurityData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     validateForgetPassword: (data: IValidateForgetPasswordData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ForgetSecurityData;
+        data: import("../..").ForgetSecurityData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").ForgetSecurityData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     confirmForgetPassword: (data: IConfirmForgetPasswordData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ForgetSecurityData;
+        data: import("../..").ForgetSecurityData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").ForgetSecurityData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     validateEmail: (data: IValidateEmailData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ValidateLimitedSecurity;
+        data: import("../..").ValidateLimitedSecurity;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").ValidateLimitedSecurity;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     validatePhone: (data: IValidatePhoneData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ValidateLimitedSecurity;
+        data: import("../..").ValidateLimitedSecurity;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").ValidateLimitedSecurity;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     verifyEmail: (data: IVerifyEmailData, options?: RequestOptions) => Promise<{
-        data: import("../../types").VerifyUserSecurity;
+        data: import("../..").VerifyUserSecurity;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").VerifyUserSecurity;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     verifyPhone: (data: IVerifyPhoneData, options?: RequestOptions) => Promise<{
-        data: import("../../types").VerifyUserSecurity;
+        data: import("../..").VerifyUserSecurity;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").VerifyUserSecurity;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     confirmEmail: (data: IConfirmEmailData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ConfirmUserSecurity;
+        data: import("../..").ConfirmUserSecurity;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").ConfirmUserSecurity;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     confirmPhone: (data: IConfirmPhoneData, options?: RequestOptions) => Promise<{
-        data: import("../../types").ConfirmUserSecurity;
+        data: import("../..").ConfirmUserSecurity;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").ConfirmUserSecurity;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
 }
 export { LimitedClient };