ggez-banking-sdk 0.1.106 → 0.1.107

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

@@ -4,16 +4,16 @@ declare class AccountClient {
     private accountService;
     constructor(clientData: AccountClientData);
     Get: (accountId: number) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").AccountData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     GetLimits: (accountId: number) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").AccountData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
 }
 export { AccountClient };

package/dist/api/clients/account.js

@@ -1,31 +1,38 @@
 import { AxiosHelper } from "../../helper";
 import { ResponseHelper } from "../../helper";
+import { FillAccountData, FillResultByError } from "../data";
 import { AccountService } from "../services";
 class AccountClient {
+    clientData;
+    accountService;
     constructor(clientData) {
         this.clientData = clientData;
-        // #region "GET"
-        this.Get = async (accountId) => {
-            try {
-                const response = await this.accountService.get(accountId);
-                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "account", "getAccount", "getAccount");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.GetLimits = async (accountId) => {
-            try {
-                const response = await this.accountService.getLimits(accountId);
-                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "account", "getAccountLimit", "getAccountLimit");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
         const { token, baseUrl, lang, installationId } = clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
         this.accountService = new AccountService(config);
     }
+    // #region "GET"
+    Get = async (accountId) => {
+        try {
+            const response = await this.accountService.get(accountId);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const accountData = FillAccountData("result", result);
+            return ResponseHelper.GetErrorResponse(accountData, "Get");
+        }
+    };
+    GetLimits = async (accountId) => {
+        try {
+            const response = await this.accountService.getLimits(accountId);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const accountData = FillAccountData("result", result);
+            return ResponseHelper.GetErrorResponse(accountData, "GetLimits");
+        }
+    };
 }
 export { AccountClient };

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

@@ -1,32 +1,37 @@
-import type { AuthClientData, IGenerateLimitedTokenData, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
+import type { AuthClientData, BaseResult, IGenerateLimitedTokenData, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
 declare class AuthClient {
     private readonly clientData;
     private programId;
     private authService;
     constructor(clientData: AuthClientData);
     LoginUserCredentials: (data: ILoginUserCredentialsData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").TokenData;
+        success: boolean;
+        message: string;
+        error: any;
+    } | {
+        data: BaseResult;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     LoginDeviceCredentials: (data: ILoginDeviceCredentialsData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: BaseResult;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     LoginGoogleCredentials: (data: ILoginGoogleCredentialsData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: BaseResult;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     GenerateLimitedToken: (data: IGenerateLimitedTokenData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: BaseResult;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
 }
 export { AuthClient };

package/dist/api/clients/auth.js

@@ -1,55 +1,70 @@
 import { AxiosHelper } from "../../helper";
 import { ResponseHelper } from "../../helper";
-import { FillGenerateLimitedTokenData, FillLoginDeviceCredentialsData, FillLoginGoogleCredentialsData, FillLoginUserCredentialsData, } from "../data";
+import { FillBaseResult, FillGenerateLimitedTokenData, FillLoginDeviceCredentialsData, FillLoginGoogleCredentialsData, FillLoginUserCredentialsData, FillResult, FillResultByError, } from "../data";
 import { AuthService } from "../services";
 class AuthClient {
+    clientData;
+    programId;
+    authService;
     constructor(clientData) {
         this.clientData = clientData;
-        // #region "POST"
-        this.LoginUserCredentials = async (data) => {
-            try {
-                const credentialsData = FillLoginUserCredentialsData(this.programId, data);
-                const response = await this.authService.login(credentialsData);
-                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginUserCredentials");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.LoginDeviceCredentials = async (data) => {
-            try {
-                const credentialsData = FillLoginDeviceCredentialsData(this.programId, data);
-                const response = await this.authService.login(credentialsData);
-                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginDeviceCredentials");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.LoginGoogleCredentials = async (data) => {
-            try {
-                const credentialsData = FillLoginGoogleCredentialsData(this.programId, data);
-                const response = await this.authService.login(credentialsData);
-                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginGoogleCredentials");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.GenerateLimitedToken = async (data) => {
-            try {
-                const tokenData = FillGenerateLimitedTokenData(data);
-                const response = await this.authService.generateLimitedToken(tokenData);
-                return ResponseHelper.GetSuccessResponse(response, {}, "security", "generateLimitedToken");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
         const { baseUrl, nodeUrl, lang, programId } = this.clientData;
         const config = AxiosHelper.GetAuthAxiosConfig(baseUrl, lang, "");
         this.authService = new AuthService(config, nodeUrl);
         this.programId = programId;
     }
+    // #region "POST"
+    LoginUserCredentials = async (data) => {
+        try {
+            const credentialsData = FillLoginUserCredentialsData(this.programId, data);
+            const response = await this.authService.login(credentialsData);
+            response.data.result = FillResult(response.data);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const baseResult = FillBaseResult("result", result);
+            return ResponseHelper.GetErrorResponse(baseResult, "LoginUserCredentials");
+        }
+    };
+    LoginDeviceCredentials = async (data) => {
+        try {
+            const credentialsData = FillLoginDeviceCredentialsData(this.programId, data);
+            const response = await this.authService.login(credentialsData);
+            response.data.result = FillResult(response.data);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const baseResult = FillBaseResult("result", result);
+            return ResponseHelper.GetErrorResponse(baseResult, "LoginDeviceCredentials");
+        }
+    };
+    LoginGoogleCredentials = async (data) => {
+        try {
+            const credentialsData = FillLoginGoogleCredentialsData(this.programId, data);
+            const response = await this.authService.login(credentialsData);
+            response.data.result = FillResult(response.data);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const baseResult = FillBaseResult("result", result);
+            return ResponseHelper.GetErrorResponse(baseResult, "LoginGoogleCredentials");
+        }
+    };
+    GenerateLimitedToken = async (data) => {
+        try {
+            const tokenData = FillGenerateLimitedTokenData(data);
+            const response = await this.authService.generateLimitedToken(tokenData);
+            response.data.result = FillResult(response.data);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const baseResult = FillBaseResult("result", result);
+            return ResponseHelper.GetErrorResponse(baseResult, "GenerateLimitedToken");
+        }
+    };
 }
 export { AuthClient };

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

@@ -4,28 +4,28 @@ declare class BlockchainClient {
     private blockchainService;
     constructor(clientData: BlockchainClientData);
     Send: (data: IBlockchainSendRequestData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     MultiSend: (data: IBlockchainMultiSendRequestData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     Delegate: (data: IBlockchainDelegateRequestData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     Undelegate: (data: IBlockchainUndelegateRequestData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../..").BlockchainData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
 }
 export { BlockchainClient };

package/dist/api/clients/blockchain.js

@@ -1,54 +1,64 @@
 import { AxiosHelper } from "../../helper";
 import { ResponseHelper } from "../../helper";
-import { FillBlockchainDelegateData, FillBlockchainMultiSendData, FillBlockchainSendData, FillBlockchainUndelegateData, } from "../data/blockchain";
+import { FillBlockchainData, FillBlockchainDelegateData, FillBlockchainMultiSendData, FillBlockchainSendData, FillBlockchainUndelegateData, FillResultByError, } from "../data";
 import { BlockchainService } from "../services/blockchain";
 class BlockchainClient {
+    clientData;
+    blockchainService;
     constructor(clientData) {
         this.clientData = clientData;
-        // #region "POST"
-        this.Send = async (data) => {
-            try {
-                const blockchainSendData = FillBlockchainSendData(data);
-                const response = await this.blockchainService.send(blockchainSendData);
-                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "send", "SendRequest", "send");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.MultiSend = async (data) => {
-            try {
-                const blockchainMultiSendData = FillBlockchainMultiSendData(data);
-                const response = await this.blockchainService.multiSend(blockchainMultiSendData);
-                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "multiSend", "MultiSendRequest", "multiSend");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.Delegate = async (data) => {
-            try {
-                const blockchainDelegateData = FillBlockchainDelegateData(data);
-                const response = await this.blockchainService.delegate(blockchainDelegateData);
-                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "delegate", "DelegateRequest", "delegate");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
-        this.Undelegate = async (data) => {
-            try {
-                const blockchainUndelegateData = FillBlockchainUndelegateData(data);
-                const response = await this.blockchainService.undelegate(blockchainUndelegateData);
-                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "undelegate", "UndelegateRequest", "undelegate");
-            }
-            catch (error) {
-                return ResponseHelper.GetErrorResponse(error);
-            }
-        };
         const { token, baseUrl, lang, installationId } = clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
         this.blockchainService = new BlockchainService(config);
     }
+    // #region "POST"
+    Send = async (data) => {
+        try {
+            const blockchainSendData = FillBlockchainSendData(data);
+            const response = await this.blockchainService.send(blockchainSendData);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const blockchainData = FillBlockchainData("result", result);
+            return ResponseHelper.GetErrorResponse(blockchainData, "Send");
+        }
+    };
+    MultiSend = async (data) => {
+        try {
+            const blockchainMultiSendData = FillBlockchainMultiSendData(data);
+            const response = await this.blockchainService.multiSend(blockchainMultiSendData);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const blockchainData = FillBlockchainData("result", result);
+            return ResponseHelper.GetErrorResponse(blockchainData, "MultiSend");
+        }
+    };
+    Delegate = async (data) => {
+        try {
+            const blockchainDelegateData = FillBlockchainDelegateData(data);
+            const response = await this.blockchainService.delegate(blockchainDelegateData);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const blockchainData = FillBlockchainData("result", result);
+            return ResponseHelper.GetErrorResponse(blockchainData, "Delegate");
+        }
+    };
+    Undelegate = async (data) => {
+        try {
+            const blockchainUndelegateData = FillBlockchainUndelegateData(data);
+            const response = await this.blockchainService.undelegate(blockchainUndelegateData);
+            return ResponseHelper.GetResponse(response.data);
+        }
+        catch (error) {
+            const result = FillResultByError(error);
+            const blockchainData = FillBlockchainData("result", result);
+            return ResponseHelper.GetErrorResponse(blockchainData, "Undelegate");
+        }
+    };
 }
 export { BlockchainClient };

package/dist/api/clients/ipAddressAndLocation.js

@@ -1,24 +1,26 @@
 import { IPAddressAndLocationService } from "../services";
 import { AxiosHelper, GeoHelper } from "../../helper";
 class IPAddressAndLocationClient {
+    clientData;
+    ipAddressAndLocationService;
     constructor(clientData) {
         this.clientData = clientData;
-        // #region "GET"
-        this.GetGeoCoordinates = async () => {
-            const data = await GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
-            return data;
-        };
-        this.GetIPAddress = async () => {
-            const data = await GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
-            return data;
-        };
-        this.GetGeoCoordinatesAndIPAddress = async () => {
-            const data = await GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
-            return data;
-        };
         const { token, baseUrl, lang, installationId } = clientData;
         const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
         this.ipAddressAndLocationService = new IPAddressAndLocationService(config);
     }
+    // #region "GET"
+    GetGeoCoordinates = async () => {
+        const data = await GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
+        return data;
+    };
+    GetIPAddress = async () => {
+        const data = await GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
+        return data;
+    };
+    GetGeoCoordinatesAndIPAddress = async () => {
+        const data = await GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
+        return data;
+    };
 }
 export { IPAddressAndLocationClient };

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

@@ -4,52 +4,62 @@ declare class LimitedClient {
     private limitedService;
     constructor(clientData: LimitedClientData);
     ValidateForgetPassword: (data: IValidateForgetPasswordData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ForgetSecurityData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     ConfirmForgetPassword: (data: IConfirmForgetPasswordData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ForgetSecurityData;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     ValidateEmail: (data: IValidateEmailData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ValidateLimitedSecurity;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     ValidatePhone: (data: IValidatePhoneData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ValidateLimitedSecurity;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     VerifyEmail: (data: IVerifyEmailData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ValidateLimitedSecurity;
+        success: boolean;
+        message: string;
+        error: string;
+    } | {
+        data: import("../../types").VerifyUserSecurity;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     VerifyPhone: (data: IVerifyPhoneData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ValidateLimitedSecurity;
+        success: boolean;
+        message: string;
+        error: string;
+    } | {
+        data: import("../../types").VerifyUserSecurity;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     ConfirmEmail: (data: IConfirmEmailData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ConfirmUserSecurity;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
     ConfirmPhone: (data: IConfirmPhoneData) => Promise<{
-        response: any;
-        status: string;
-        newUser: any;
-        message: any;
+        data: import("../../types").ConfirmUserSecurity;
+        success: boolean;
+        message: string;
+        error: any;
     }>;
 }
 export { LimitedClient };