ggez-banking-sdk 0.3.26 → 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/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/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/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/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 };

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

@@ -4,10 +4,15 @@ declare class OrderClient extends BaseClient {
     private orderService;
     constructor(clientData: OrderClientData, errorHandler: ErrorHandler);
     createOrder: (data: ICreateOrderData, options?: RequestOptions) => Promise<{
-        data: import("../../types").OrderData;
+        data: import("../..").OrderData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").OrderData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
 }
 export { OrderClient };

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

@@ -6,34 +6,59 @@ declare class OrganizationClient extends BaseClient {
     private userId;
     constructor(clientData: OrganizationClientData, errorHandler: ErrorHandler);
     getOrganization: (id: number, options?: RequestOptions) => Promise<{
-        data: import("../../types").OrganizationData;
+        data: import("../..").OrganizationData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").OrganizationData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     createOrganization: (data: ICreateOrganizationData, options?: RequestOptions) => Promise<{
-        data: import("../../types").OrganizationData;
+        data: import("../..").OrganizationData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").OrganizationData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     uploadDocument: (data: IUploadOrganizationDocumentData, options?: RequestOptions) => Promise<{
-        data: import("../../types").DocumentData;
+        data: import("../..").DocumentData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").DocumentData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     updateOrganization: (data: IUpdateOrganizationData, options?: RequestOptions) => Promise<{
-        data: import("../../types").OrganizationData;
+        data: import("../..").OrganizationData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").OrganizationData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     deleteOrganization: (id: number, options?: RequestOptions) => Promise<{
-        data: import("../../types").OrganizationData;
+        data: import("../..").OrganizationData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").OrganizationData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
 }
 export { OrganizationClient };

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

@@ -7,19 +7,34 @@ declare class ProgramClient extends BaseClient {
         data: import("../../types/banking/program").ProgramData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../../types/banking/program").ProgramData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     getBin: (options?: RequestOptions) => Promise<{
         data: import("../../types/banking/program").ProgramData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../../types/banking/program").ProgramData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     getSignUp: (options?: RequestOptions) => Promise<{
         data: import("../../types/banking/program").ProgramData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../../types/banking/program").ProgramData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
 }
 export { ProgramClient };

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

@@ -1,15 +1,15 @@
-import type { BaseResult, ErrorHandler, GGEZGiftRewards, PromotionClientData, PromotionDetails, RequestOptions } from "../../types";
+import type { BaseResult, ErrorHandler, GGEZGiftRewards, PromotionClientData, RequestOptions } from "../../types";
 import { BaseClient } from "./base";
 declare class PromotionClient extends BaseClient {
     private promotionService;
     constructor(clientData: PromotionClientData, errorHandler: ErrorHandler);
     getPromotionByCode: (code: string, options?: RequestOptions) => Promise<{
-        data: PromotionDetails;
+        data: import("../..").PromotionDetails;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
     } | {
-        data: any;
+        data: null;
         success: boolean;
         message: string;
         error: string;
@@ -18,9 +18,9 @@ declare class PromotionClient extends BaseClient {
         data: BaseResult;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
     } | {
-        data: any;
+        data: BaseResult;
         success: boolean;
         message: string;
         error: string;
@@ -31,9 +31,9 @@ declare class PromotionClient extends BaseClient {
         };
         success: boolean;
         message: string;
-        error: any;
+        error: null;
     } | {
-        data: any;
+        data: null;
         success: boolean;
         message: string;
         error: string;

package/dist/api/clients/promotion.js

@@ -1,6 +1,7 @@
 import { AxiosHelper } from "../../helper/api/axiosHelper";
 import { PromotionService } from "../services";
 import { BaseClient } from "./base";
+import { createDefaultBaseResult, fillResultByError } from "../data";
 class PromotionClient extends BaseClient {
     promotionService;
     constructor(clientData, errorHandler) {
@@ -31,7 +32,9 @@ class PromotionClient extends BaseClient {
             return this.responseHelper.getResponse(response);
         }
         catch (error) {
-            return this.responseHelper.getErrorResponse(error, "getTwitterSpotlightPostIds");
+            const result = fillResultByError(error);
+            const data = createDefaultBaseResult({ result });
+            return this.responseHelper.getErrorResponse(data, "getTwitterSpotlightPostIds");
         }
     };
     // #endregion

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

@@ -4,28 +4,48 @@ declare class TransactionClient extends BaseClient {
     private transactionService;
     constructor(clientData: TransactionClientData, errorHandler: ErrorHandler);
     inquiryTransaction: (params: IInquiryTransactionData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TransactionResultInquiry;
+        data: import("../..").TransactionResultInquiry;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").TransactionResultInquiry;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     createSystemTransaction: (data: ICreateSystemTransactionData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TransactionData;
+        data: import("../..").TransactionData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").TransactionData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
     createBlockchainTransaction: (data: ICreateBlockchainTransactionData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TransactionData;
+        data: import("../..").TransactionData;
         success: boolean;
         message: string;
-        error: any;
+        error: null;
+    } | {
+        data: import("../..").TransactionData;
+        success: boolean;
+        message: string;
+        error: string;
     }>;
     createGatewayCryptoTransaction: (data: ICreateGatewayCryptoTransactionData, options?: RequestOptions) => Promise<{
-        data: import("../../types").TransactionData;
+        data: import("../..").TransactionData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").TransactionData;
         success: boolean;
         message: string;
-        error: any;
+        error: string;
     }>;
 }
 export { TransactionClient };