ggez-banking-sdk 0.3.23 → 0.3.25

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

@@ -11,7 +11,7 @@ class AccountClient extends BaseClient {
         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);
@@ -19,10 +19,10 @@ class AccountClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const accountData = CreateDefaultAccountData({ result });
-            return this.responseHelper.GetErrorResponse(accountData, "Get");
+            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);
@@ -30,7 +30,7 @@ class AccountClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const accountData = CreateDefaultAccountData({ result });
-            return this.responseHelper.GetErrorResponse(accountData, "GetLimits");
+            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

@@ -13,7 +13,7 @@ class AuthClient extends BaseClient {
         this.programId = programId;
     }
     // #region "POST"
-    LoginUserCredentials = async (data, options) => {
+    loginUserCredentials = async (data, options) => {
         try {
             const credentialsData = FillLoginUserCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData, options);
@@ -23,10 +23,10 @@ class AuthClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "LoginUserCredentials");
+            return this.responseHelper.GetErrorResponse(tokenData, "loginUserCredentials");
         }
     };
-    LoginDeviceCredentials = async (data, options) => {
+    loginDeviceCredentials = async (data, options) => {
         try {
             const credentialsData = FillLoginDeviceCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData, options);
@@ -36,10 +36,10 @@ class AuthClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "LoginDeviceCredentials");
+            return this.responseHelper.GetErrorResponse(tokenData, "loginDeviceCredentials");
         }
     };
-    LoginGoogleCredentials = async (data, options) => {
+    loginGoogleCredentials = async (data, options) => {
         try {
             const credentialsData = FillLoginGoogleCredentialsData(this.programId, data);
             const response = await this.authService.login(credentialsData, options);
@@ -49,10 +49,10 @@ class AuthClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "LoginGoogleCredentials");
+            return this.responseHelper.GetErrorResponse(tokenData, "loginGoogleCredentials");
         }
     };
-    GenerateLimitedToken = async (data, options) => {
+    generateLimitedToken = async (data, options) => {
         try {
             const tokenData = FillGenerateLimitedTokenData(data);
             const response = await this.authService.generateLimitedToken(tokenData, options);
@@ -62,7 +62,7 @@ class AuthClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const tokenData = CreateDefaultTokenData({ result });
-            return this.responseHelper.GetErrorResponse(tokenData, "GenerateLimitedToken");
+            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

@@ -11,7 +11,7 @@ class BlockchainClient extends BaseClient {
         this.blockchainService = new BlockchainService({ config, userId });
     }
     // #region "POST"
-    Send = async (data, options) => {
+    send = async (data, options) => {
         try {
             const blockchainSendData = FillBlockchainSendData(data);
             const response = await this.blockchainService.send(blockchainSendData, options);
@@ -20,10 +20,10 @@ class BlockchainClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "Send");
+            return this.responseHelper.GetErrorResponse(blockchainData, "send");
         }
     };
-    MultiSend = async (data, options) => {
+    multiSend = async (data, options) => {
         try {
             const blockchainMultiSendData = FillBlockchainMultiSendData(data);
             const response = await this.blockchainService.multiSend(blockchainMultiSendData, options);
@@ -32,10 +32,10 @@ class BlockchainClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "MultiSend");
+            return this.responseHelper.GetErrorResponse(blockchainData, "multiSend");
         }
     };
-    Delegate = async (data, options) => {
+    delegate = async (data, options) => {
         try {
             const blockchainDelegateData = FillBlockchainDelegateData(data);
             const response = await this.blockchainService.delegate(blockchainDelegateData, options);
@@ -44,10 +44,10 @@ class BlockchainClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "Delegate");
+            return this.responseHelper.GetErrorResponse(blockchainData, "delegate");
         }
     };
-    Undelegate = async (data, options) => {
+    undelegate = async (data, options) => {
         try {
             const blockchainUndelegateData = FillBlockchainUndelegateData(data);
             const response = await this.blockchainService.undelegate(blockchainUndelegateData, options);
@@ -56,7 +56,7 @@ class BlockchainClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const blockchainData = CreateDefaultBlockchainData({ result });
-            return this.responseHelper.GetErrorResponse(blockchainData, "Undelegate");
+            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

@@ -14,7 +14,7 @@ class IPAddressAndLocationClient extends BaseClient {
         });
     }
     // #region "GET"
-    GetGeoCoordinates = () => {
+    getGeoCoordinates = () => {
         try {
             return GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
         }
@@ -22,7 +22,7 @@ class IPAddressAndLocationClient extends BaseClient {
             return { latitude: 0, longitude: 0, position_description: "N/A, N/A" };
         }
     };
-    GetIPAddress = () => {
+    getIPAddress = () => {
         try {
             return GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
         }
@@ -30,7 +30,7 @@ class IPAddressAndLocationClient extends BaseClient {
             return "";
         }
     };
-    GetGeoCoordinatesAndIPAddress = () => {
+    getGeoCoordinatesAndIPAddress = () => {
         try {
             return GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
         }

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;

package/dist/api/clients/limited.js

@@ -15,7 +15,7 @@ class LimitedClient extends BaseClient {
         });
     }
     // #region "POST"
-    CheckForgetPassword = async (data, options) => {
+    checkForgetPassword = async (data, options) => {
         try {
             const forgetSecurityData = FillCheckForgetPasswordData(data);
             const response = await this.limitedService.checkForgetSecurityData(forgetSecurityData, options);
@@ -24,10 +24,10 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = CreateDefaultForgetSecurityData({ result });
-            return this.responseHelper.GetErrorResponse(forgetSecurityData, "CheckForgetPassword");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "checkForgetPassword");
         }
     };
-    ValidateForgetPassword = async (data, options) => {
+    validateForgetPassword = async (data, options) => {
         try {
             const forgetSecurityData = FillValidateForgetPasswordData(data);
             const response = await this.limitedService.validateForgetSecurityData(forgetSecurityData, options);
@@ -36,10 +36,10 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = CreateDefaultForgetSecurityData({ result });
-            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ValidateForgetPassword");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "validateForgetPassword");
         }
     };
-    ConfirmForgetPassword = async (data, options) => {
+    confirmForgetPassword = async (data, options) => {
         try {
             const forgetSecurityData = FillConfirmForgetPasswordData(data);
             const response = await this.limitedService.confirmForgetSecurityData(forgetSecurityData, options);
@@ -48,10 +48,10 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const forgetSecurityData = CreateDefaultForgetSecurityData({ result });
-            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ConfirmForgetPassword");
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "confirmForgetPassword");
         }
     };
-    ValidateEmail = async (data, options) => {
+    validateEmail = async (data, options) => {
         try {
             const validateLimitedSecurity = FillValidateEmailData(data);
             const response = await this.limitedService.validateSecurityData(validateLimitedSecurity, options);
@@ -59,11 +59,13 @@ class LimitedClient extends BaseClient {
         }
         catch (error) {
             const result = FillResultByError(error);
-            const forgetSecurityData = CreateDefaultValidateLimitedSecurity({ result });
-            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ConfirmForgetPassword");
+            const forgetSecurityData = CreateDefaultValidateLimitedSecurity({
+                result,
+            });
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "validateEmail");
         }
     };
-    ValidatePhone = async (data, options) => {
+    validatePhone = async (data, options) => {
         try {
             const validateLimitedSecurity = FillValidatePhoneData(data);
             const response = await this.limitedService.validateSecurityData(validateLimitedSecurity, options);
@@ -71,11 +73,13 @@ class LimitedClient extends BaseClient {
         }
         catch (error) {
             const result = FillResultByError(error);
-            const forgetSecurityData = CreateDefaultValidateLimitedSecurity({ result });
-            return this.responseHelper.GetErrorResponse(forgetSecurityData, "ValidatePhone");
+            const forgetSecurityData = CreateDefaultValidateLimitedSecurity({
+                result,
+            });
+            return this.responseHelper.GetErrorResponse(forgetSecurityData, "validatePhone");
         }
     };
-    VerifyEmail = async (data, options) => {
+    verifyEmail = async (data, options) => {
         try {
             const verifyUserSecurity = FillVerifyEmailData(data);
             const response = await this.limitedService.verifySecurityData(verifyUserSecurity, options);
@@ -84,10 +88,10 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const verifySecurityData = CreateDefaultVerifyUserSecurity({ result });
-            return this.responseHelper.GetErrorResponse(verifySecurityData, "VerifyEmail");
+            return this.responseHelper.GetErrorResponse(verifySecurityData, "verifyEmail");
         }
     };
-    VerifyPhone = async (data, options) => {
+    verifyPhone = async (data, options) => {
         try {
             const verifyUserSecurity = FillVerifyPhoneData(data);
             const response = await this.limitedService.verifySecurityData(verifyUserSecurity, options);
@@ -96,10 +100,10 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const verifySecurityData = CreateDefaultVerifyUserSecurity({ result });
-            return this.responseHelper.GetErrorResponse(verifySecurityData, "VerifyPhone");
+            return this.responseHelper.GetErrorResponse(verifySecurityData, "verifyPhone");
         }
     };
-    ConfirmEmail = async (data, options) => {
+    confirmEmail = async (data, options) => {
         try {
             const confirmUserSecurity = FillConfirmEmailData(data);
             const response = await this.limitedService.confirmSecurityData(confirmUserSecurity, options);
@@ -108,10 +112,10 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const confirmUserSecurity = CreateDefaultConfirmUserSecurity({ result });
-            return this.responseHelper.GetErrorResponse(confirmUserSecurity, "ConfirmEmail");
+            return this.responseHelper.GetErrorResponse(confirmUserSecurity, "confirmEmail");
         }
     };
-    ConfirmPhone = async (data, options) => {
+    confirmPhone = async (data, options) => {
         try {
             const confirmUserSecurity = FillConfirmPhoneData(data);
             const response = await this.limitedService.confirmSecurityData(confirmUserSecurity, options);
@@ -120,7 +124,7 @@ class LimitedClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const confirmUserSecurity = CreateDefaultConfirmUserSecurity({ result });
-            return this.responseHelper.GetErrorResponse(confirmUserSecurity, "ConfirmPhone");
+            return this.responseHelper.GetErrorResponse(confirmUserSecurity, "confirmPhone");
         }
     };
 }

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

@@ -3,7 +3,7 @@ import { BaseClient } from "./base";
 declare class OrderClient extends BaseClient {
     private orderService;
     constructor(clientData: OrderClientData, errorHandler: ErrorHandler);
-    CreateOrder: (data: ICreateOrderData, options?: RequestOptions) => Promise<{
+    createOrder: (data: ICreateOrderData, options?: RequestOptions) => Promise<{
         data: import("../../types").OrderData;
         success: boolean;
         message: string;

package/dist/api/clients/order.js

@@ -1,5 +1,5 @@
 import { AxiosHelper } from "../../helper/api/axiosHelper";
-import { FillCreateOrderData, CreateDefaultOrderData, FillResultByError } from "../data";
+import { FillCreateOrderData, CreateDefaultOrderData, FillResultByError, } from "../data";
 import { OrderService } from "../services";
 import { BaseClient } from "./base";
 class OrderClient extends BaseClient {
@@ -11,7 +11,7 @@ class OrderClient extends BaseClient {
         this.orderService = new OrderService({ config, userId });
     }
     // #region "POST"
-    CreateOrder = async (data, options) => {
+    createOrder = async (data, options) => {
         try {
             const createOrderData = FillCreateOrderData(data);
             const response = await this.orderService.create(createOrderData, options);
@@ -20,7 +20,7 @@ class OrderClient extends BaseClient {
         catch (error) {
             const result = FillResultByError(error);
             const orderData = CreateDefaultOrderData({ result });
-            return this.responseHelper.GetErrorResponse(orderData, "CreateOrder");
+            return this.responseHelper.GetErrorResponse(orderData, "createOrder");
         }
     };
 }

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

@@ -5,31 +5,31 @@ declare class OrganizationClient extends BaseClient {
     private organizationService;
     private userId;
     constructor(clientData: OrganizationClientData, errorHandler: ErrorHandler);
-    GetOrganization: (id: number, options?: RequestOptions) => Promise<{
+    getOrganization: (id: number, options?: RequestOptions) => Promise<{
         data: import("../../types").OrganizationData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    CreateOrganization: (data: ICreateOrganizationData, options?: RequestOptions) => Promise<{
+    createOrganization: (data: ICreateOrganizationData, options?: RequestOptions) => Promise<{
         data: import("../../types").OrganizationData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    UploadDocument: (data: IUploadOrganizationDocumentData, options?: RequestOptions) => Promise<{
+    uploadDocument: (data: IUploadOrganizationDocumentData, options?: RequestOptions) => Promise<{
         data: import("../../types").DocumentData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    UpdateOrganization: (data: IUpdateOrganizationData, options?: RequestOptions) => Promise<{
+    updateOrganization: (data: IUpdateOrganizationData, options?: RequestOptions) => Promise<{
         data: import("../../types").OrganizationData;
         success: boolean;
         message: string;
         error: any;
     }>;
-    DeleteOrganization: (id: number, options?: RequestOptions) => Promise<{
+    deleteOrganization: (id: number, options?: RequestOptions) => Promise<{
         data: import("../../types").OrganizationData;
         success: boolean;
         message: string;