ggez-banking-sdk 0.3.24 → 0.3.26

package/dist/api/api.d.ts

@@ -0,0 +1,29 @@
+import { AccountClient, AuthClient, BlockchainClient, ClientData, ErrorHandler, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient } from "..";
+declare class API {
+    private _account;
+    private _auth;
+    private _blockchain;
+    private _ipAddress;
+    private _limited;
+    private _order;
+    private _organization;
+    private _program;
+    private _promotion;
+    private _transaction;
+    private _user;
+    private errorHandler;
+    private clientData;
+    constructor(clientData: ClientData, errorHandler: ErrorHandler);
+    get account(): AccountClient;
+    get auth(): AuthClient;
+    get blockchain(): BlockchainClient;
+    get ipAddress(): IPAddressAndLocationClient;
+    get limited(): LimitedClient;
+    get order(): OrderClient;
+    get organization(): OrganizationClient;
+    get program(): ProgramClient;
+    get promotion(): PromotionClient;
+    get transaction(): TransactionClient;
+    get user(): UserClient;
+}
+export { API };

package/dist/api/api.js

@@ -0,0 +1,95 @@
+import { AccountClient, AuthClient, BlockchainClient, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient, } from "..";
+class API {
+    // #region "Properties"
+    _account = null;
+    _auth = null;
+    _blockchain = null;
+    _ipAddress = null;
+    _limited = null;
+    _order = null;
+    _organization = null;
+    _program = null;
+    _promotion = null;
+    _transaction = null;
+    _user = null;
+    errorHandler;
+    clientData;
+    // #endregion
+    // #region "Constructor"
+    constructor(clientData, errorHandler) {
+        this.errorHandler = errorHandler;
+        this.clientData = clientData;
+    }
+    // #endregion
+    // #region "Clients"
+    get account() {
+        if (!this._account) {
+            this._account = new AccountClient(this.clientData, this.errorHandler);
+        }
+        return this._account;
+    }
+    get auth() {
+        if (!this._auth) {
+            this._auth = new AuthClient(this.clientData, this.errorHandler);
+        }
+        return this._auth;
+    }
+    get blockchain() {
+        if (!this._blockchain) {
+            this._blockchain = new BlockchainClient(this.clientData, this.errorHandler);
+        }
+        return this._blockchain;
+    }
+    get ipAddress() {
+        if (!this._ipAddress) {
+            this._ipAddress = new IPAddressAndLocationClient(this.clientData, this.errorHandler);
+        }
+        return this._ipAddress;
+    }
+    get limited() {
+        if (!this._limited) {
+            this._limited = new LimitedClient(this.clientData, this.errorHandler);
+        }
+        return this._limited;
+    }
+    get order() {
+        if (!this._order) {
+            this._order = new OrderClient(this.clientData, this.errorHandler);
+        }
+        return this._order;
+    }
+    get organization() {
+        if (!this._organization) {
+            this._organization = new OrganizationClient(this.clientData, this.errorHandler);
+        }
+        return this._organization;
+    }
+    get program() {
+        if (!this._program) {
+            this._program = new ProgramClient(this.clientData, this.errorHandler);
+        }
+        return this._program;
+    }
+    get promotion() {
+        if (!this._promotion) {
+            this._promotion = new PromotionClient(this.clientData, this.errorHandler);
+        }
+        return this._promotion;
+    }
+    get transaction() {
+        if (!this._transaction) {
+            this._transaction = new TransactionClient(this.clientData, this.errorHandler);
+        }
+        return this._transaction;
+    }
+    get user() {
+        if (!this._user) {
+            this._user = new UserClient(this.clientData, this.errorHandler);
+        }
+        return this._user;
+    }
+}
+const api = new API({}, (error) => {
+    console.error("API Error:", error);
+});
+export { API };

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

@@ -4,13 +4,13 @@ import { BaseClient } from "./base";
 declare class AccountClient extends BaseClient {
     private accountService;
     constructor(clientData: AccountClientData, errorHandler: ErrorHandler);
-    Get: (accountId: number, options?: RequestOptions) => Promise<{
+    get: (accountId: number, options?: RequestOptions) => Promise<{
         data: import("../..").AccountData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    GetLimits: (accountId: number, options?: RequestOptions) => Promise<{
+    getLimits: (accountId: number, options?: RequestOptions) => Promise<{
         data: import("../..").AccountData;
         success: boolean;
         message: string;

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

@@ -4,25 +4,25 @@ declare class AuthClient extends BaseClient {
     private programId;
     private authService;
     constructor(clientData: AuthClientData, errorHandler: ErrorHandler);
-    LoginUserCredentials: (data: ILoginUserCredentialsData, options?: RequestOptions) => Promise<{
+    loginUserCredentials: (data: ILoginUserCredentialsData, options?: RequestOptions) => Promise<{
         data: import("../../types").TokenData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    LoginDeviceCredentials: (data: ILoginDeviceCredentialsData, options?: RequestOptions) => Promise<{
+    loginDeviceCredentials: (data: ILoginDeviceCredentialsData, options?: RequestOptions) => Promise<{
         data: import("../../types").TokenData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    LoginGoogleCredentials: (data: ILoginGoogleCredentialsData, options?: RequestOptions) => Promise<{
+    loginGoogleCredentials: (data: ILoginGoogleCredentialsData, options?: RequestOptions) => Promise<{
         data: import("../../types").TokenData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    GenerateLimitedToken: (data: IGenerateLimitedTokenData, options?: RequestOptions) => Promise<{
+    generateLimitedToken: (data: IGenerateLimitedTokenData, options?: RequestOptions) => Promise<{
         data: import("../../types").TokenData;
         success: boolean;
         message: string;

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

@@ -3,25 +3,25 @@ import { BaseClient } from "./base";
 declare class BlockchainClient extends BaseClient {
     private blockchainService;
     constructor(clientData: BlockchainClientData, errorHandler: ErrorHandler);
-    Send: (data: IBlockchainSendRequestData, options?: RequestOptions) => Promise<{
+    send: (data: IBlockchainSendRequestData, options?: RequestOptions) => Promise<{
         data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    MultiSend: (data: IBlockchainMultiSendRequestData, options?: RequestOptions) => Promise<{
+    multiSend: (data: IBlockchainMultiSendRequestData, options?: RequestOptions) => Promise<{
         data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    Delegate: (data: IBlockchainDelegateRequestData, options?: RequestOptions) => Promise<{
+    delegate: (data: IBlockchainDelegateRequestData, options?: RequestOptions) => Promise<{
         data: import("../../types").BlockchainData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    Undelegate: (data: IBlockchainUndelegateRequestData, options?: RequestOptions) => Promise<{
+    undelegate: (data: IBlockchainUndelegateRequestData, options?: RequestOptions) => Promise<{
         data: import("../../types").BlockchainData;
         success: boolean;
         message: string;

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

package/dist/api/clients/ipAddressAndLocation.js

@@ -7,32 +7,32 @@ 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,
         });
     }
     // #region "GET"
-    GetGeoCoordinates = () => {
+    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" };
         }
     };
-    GetIPAddress = () => {
+    getIPAddress = () => {
         try {
-            return GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
+            return GeoHelper.getIPAddress(this.ipAddressAndLocationService);
         }
         catch (error) {
             return "";
         }
     };
-    GetGeoCoordinatesAndIPAddress = () => {
+    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

@@ -3,55 +3,55 @@ import { BaseClient } from "./base";
 declare class LimitedClient extends BaseClient {
     private limitedService;
     constructor(clientData: LimitedClientData, errorHandler: ErrorHandler);
-    CheckForgetPassword: (data: ICheckForgetPasswordData, options?: RequestOptions) => Promise<{
+    checkForgetPassword: (data: ICheckForgetPasswordData, options?: RequestOptions) => Promise<{
         data: import("../../types").ForgetSecurityData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    ValidateForgetPassword: (data: IValidateForgetPasswordData, options?: RequestOptions) => Promise<{
+    validateForgetPassword: (data: IValidateForgetPasswordData, options?: RequestOptions) => Promise<{
         data: import("../../types").ForgetSecurityData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    ConfirmForgetPassword: (data: IConfirmForgetPasswordData, options?: RequestOptions) => Promise<{
+    confirmForgetPassword: (data: IConfirmForgetPasswordData, options?: RequestOptions) => Promise<{
         data: import("../../types").ForgetSecurityData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    ValidateEmail: (data: IValidateEmailData, options?: RequestOptions) => Promise<{
+    validateEmail: (data: IValidateEmailData, options?: RequestOptions) => Promise<{
         data: import("../../types").ValidateLimitedSecurity;
         success: boolean;
         message: string;
         error: any;
     }>;
-    ValidatePhone: (data: IValidatePhoneData, options?: RequestOptions) => Promise<{
+    validatePhone: (data: IValidatePhoneData, options?: RequestOptions) => Promise<{
         data: import("../../types").ValidateLimitedSecurity;
         success: boolean;
         message: string;
         error: any;
     }>;
-    VerifyEmail: (data: IVerifyEmailData, options?: RequestOptions) => Promise<{
+    verifyEmail: (data: IVerifyEmailData, options?: RequestOptions) => Promise<{
         data: import("../../types").VerifyUserSecurity;
         success: boolean;
         message: string;
         error: any;
     }>;
-    VerifyPhone: (data: IVerifyPhoneData, options?: RequestOptions) => Promise<{
+    verifyPhone: (data: IVerifyPhoneData, options?: RequestOptions) => Promise<{
         data: import("../../types").VerifyUserSecurity;
         success: boolean;
         message: string;
         error: any;
     }>;
-    ConfirmEmail: (data: IConfirmEmailData, options?: RequestOptions) => Promise<{
+    confirmEmail: (data: IConfirmEmailData, options?: RequestOptions) => Promise<{
         data: import("../../types").ConfirmUserSecurity;
         success: boolean;
         message: string;
         error: any;
     }>;
-    ConfirmPhone: (data: IConfirmPhoneData, options?: RequestOptions) => Promise<{
+    confirmPhone: (data: IConfirmPhoneData, options?: RequestOptions) => Promise<{
         data: import("../../types").ConfirmUserSecurity;
         success: boolean;
         message: string;