ggez-banking-sdk 0.1.82 → 0.1.88

package/dist/api/services/base.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+declare abstract class BaseService {
+    protected axiosInstance: AxiosInstance;
+    protected abstract endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    protected resolveURL(path?: string): string;
+    protected GET<T>(url: string, params?: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;
+    protected POST<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;
+    protected PUT<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;
+    protected DELETE<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;
+}
+export { BaseService };

package/dist/api/services/base.js

@@ -0,0 +1,61 @@
+import axios from "axios";
+import { AxiosHelper } from "../../helper";
+class BaseService {
+    constructor(config) {
+        this.axiosInstance = axios.create(config);
+        this.axiosInstance.interceptors.request.use((req) => {
+            AxiosHelper.InjectRequiredHeaders(req);
+            AxiosHelper.InjectBaseBodyProperties(req);
+            return req;
+        });
+    }
+    resolveURL(path = "") {
+        if (path && !path.startsWith("/")) {
+            path = `/${path}`;
+        }
+        return `${this.endpoint}${path}`;
+    }
+    async GET(url, params, config) {
+        try {
+            return this.axiosInstance.get(url, {
+                ...config,
+                params,
+            });
+        }
+        catch (ex) {
+            console.error(ex);
+            // onErrorHandler(ex);
+        }
+    }
+    async POST(url, data, config) {
+        try {
+            return this.axiosInstance.post(url, data, config);
+        }
+        catch (ex) {
+            console.error(ex);
+            // onErrorHandler(ex);
+        }
+    }
+    async PUT(url, data, config) {
+        try {
+            return this.axiosInstance.put(url, data, config);
+        }
+        catch (ex) {
+            console.error(ex);
+            // onErrorHandler(ex);
+        }
+    }
+    async DELETE(url, data, config) {
+        try {
+            return this.axiosInstance.delete(url, {
+                ...config,
+                data,
+            });
+        }
+        catch (ex) {
+            console.error(ex);
+            // onErrorHandler(ex);
+        }
+    }
+}
+export { BaseService };

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

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { BlockchainData } from "../../types";
+declare class BlockchainService extends BaseService {
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    send(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
+    multiSend(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
+    delegate(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
+    undelegate(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
+}
+export { BlockchainService };

package/dist/api/services/blockchain.js

@@ -0,0 +1,30 @@
+import { Endpoints } from "../../constants";
+import { BaseService } from "./base";
+class BlockchainService extends BaseService {
+    constructor(config) {
+        super(config);
+        this.endpoint = Endpoints.Blockchain;
+    }
+    // #region "POST"
+    async send(payload) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, payload);
+        return response;
+    }
+    async multiSend(payload) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, payload);
+        return response;
+    }
+    async delegate(payload) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, payload);
+        return response;
+    }
+    async undelegate(payload) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, payload);
+        return response;
+    }
+}
+export { BlockchainService };

package/dist/api/services/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./account";
+export * from "./auth";
+export * from "./base";
+export * from "./blockchain";
+export * from "./ipAddressAndLocation";
+export * from "./limited";
+export * from "./auth";
+export * from "./blockchain";
+export * from "./ipAddressAndLocation";
+export * from "./limited";
+export * from "./order";
+export * from "./organization";
+export * from "./promotion";
+export * from "./transaction";
+export * from "./user";

package/dist/api/services/index.js

@@ -0,0 +1,15 @@
+export * from "./account";
+export * from "./auth";
+export * from "./base";
+export * from "./blockchain";
+export * from "./ipAddressAndLocation";
+export * from "./limited";
+export * from "./auth";
+export * from "./blockchain";
+export * from "./ipAddressAndLocation";
+export * from "./limited";
+export * from "./order";
+export * from "./organization";
+export * from "./promotion";
+export * from "./transaction";
+export * from "./user";

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

@@ -0,0 +1,8 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+declare class IPAddressAndLocationService extends BaseService {
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    getIPAddressAndLocation: () => Promise<import("axios").AxiosResponse<string, any, {}>>;
+}
+export { IPAddressAndLocationService };

package/dist/api/services/ipAddressAndLocation.js

@@ -0,0 +1,18 @@
+import { BaseService } from "./base";
+import { Endpoints } from "../../constants";
+class IPAddressAndLocationService extends BaseService {
+    constructor(config) {
+        super(config);
+        this.endpoint = Endpoints.IPAddress;
+        // #region "GET"
+        this.getIPAddressAndLocation = async () => {
+            try {
+                return this.GET(this.endpoint);
+            }
+            catch (error) {
+                // console.error(error);
+            }
+        };
+    }
+}
+export { IPAddressAndLocationService };

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

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { ConfirmUserSecurity, ForgetSecurityData, ValidateLimitedSecurity, VerifyUserSecurity } from "../../types";
+declare class LimitedService extends BaseService {
+    endpoint: string;
+    private nodeUrl;
+    constructor(config: AxiosRequestConfig, nodeUrl: string);
+    validateForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
+    confirmForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
+    validateSecurityData(data: ValidateLimitedSecurity): Promise<import("axios").AxiosResponse<ValidateLimitedSecurity, any, {}>>;
+    verifySecurityData(data: VerifyUserSecurity): Promise<import("axios").AxiosResponse<VerifyUserSecurity, any, {}>>;
+    confirmSecurityData(data: ConfirmUserSecurity): Promise<import("axios").AxiosResponse<ConfirmUserSecurity, any, {}>>;
+}
+export { LimitedService };

package/dist/api/services/limited.js

@@ -0,0 +1,43 @@
+import { Endpoints, LimitedEndpoints } from "../../constants";
+import { BaseService } from "./base";
+import { AuthService } from "./auth";
+import { AxiosHelper } from "../../helper";
+class LimitedService extends BaseService {
+    constructor(config, nodeUrl) {
+        super(config);
+        this.endpoint = Endpoints.Limited;
+        this.nodeUrl = nodeUrl;
+        this.axiosInstance.interceptors.request.use(async (req) => {
+            const config = AxiosHelper.GetAuthAxiosConfig(this.nodeUrl, "", "");
+            const authService = new AuthService(config, this.nodeUrl);
+            const { data } = await authService.generateLimitedToken();
+            const token = data?.access_token;
+            if (token) {
+                req.headers.setAuthorization(`Bearer ${token}`);
+            }
+            return req;
+        });
+    }
+    // #region "POST"
+    async validateForgetSecurityData(data) {
+        const url = this.resolveURL(`${LimitedEndpoints.SecurityForgetValidate}`);
+        return await this.POST(url, data);
+    }
+    async confirmForgetSecurityData(data) {
+        const url = this.resolveURL(`${LimitedEndpoints.SecurityForgetConfirm}`);
+        return await this.POST(url, data);
+    }
+    async validateSecurityData(data) {
+        const url = this.resolveURL(`${LimitedEndpoints.SecurityValidate}`);
+        return await this.POST(url, data);
+    }
+    async verifySecurityData(data) {
+        const url = this.resolveURL(`${LimitedEndpoints.SecurityVerify}`);
+        return await this.POST(url, data);
+    }
+    async confirmSecurityData(data) {
+        const url = this.resolveURL(`${LimitedEndpoints.SecurityConfirm}`);
+        return await this.POST(url, data);
+    }
+}
+export { LimitedService };

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

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { OrderData } from "../../types";
+declare class OrderService extends BaseService {
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    create(data: OrderData): Promise<import("axios").AxiosResponse<OrderData, any, {}>>;
+}
+export { OrderService };

package/dist/api/services/order.js

@@ -0,0 +1,24 @@
+import { Endpoints } from "../../constants";
+import { BaseService } from "./base";
+import { IPAddressAndLocationService } from "..";
+import { GeoHelper } from "../../helper";
+import { AxiosHelper } from "../../helper";
+class OrderService extends BaseService {
+    constructor(config) {
+        super(config);
+        this.endpoint = Endpoints.Order;
+        this.axiosInstance.interceptors.request.use(async (req) => {
+            const locationService = new IPAddressAndLocationService(config);
+            const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
+            AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
+            return req;
+        });
+    }
+    // #region "POST"
+    async create(data) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, data);
+        return response;
+    }
+}
+export { OrderService };

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

@@ -0,0 +1,13 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { DocumentData, OrganizationData } from "../../types";
+declare class OrganizationService extends BaseService {
+    url: string;
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    create(data: OrganizationData): Promise<import("axios").AxiosResponse<OrganizationData, any, {}>>;
+    createDocument(id: string, data: DocumentData): Promise<import("axios").AxiosResponse<DocumentData, any, {}>>;
+    update(id: string, data: OrganizationData): Promise<import("axios").AxiosResponse<OrganizationData, any, {}>>;
+    delete(id: number): Promise<import("axios").AxiosResponse<OrganizationData, any, {}>>;
+}
+export { OrganizationService };

package/dist/api/services/organization.js

@@ -0,0 +1,43 @@
+import { Endpoints, OrganizationEndpoints } from "../../constants";
+import { BaseService } from "./base";
+import { IPAddressAndLocationService } from "..";
+import { GeoHelper } from "../../helper";
+import { AxiosHelper } from "../../helper";
+class OrganizationService extends BaseService {
+    constructor(config) {
+        super(config);
+        this.endpoint = Endpoints.Organization;
+        this.axiosInstance.interceptors.request.use(async (req) => {
+            const locationService = new IPAddressAndLocationService(config);
+            const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
+            AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
+            return req;
+        });
+    }
+    // #region "POST"
+    async create(data) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, data);
+        return response;
+    }
+    async createDocument(id, data) {
+        const url = this.resolveURL(`${OrganizationEndpoints.Document}/${id}`);
+        const response = await this.POST(url, data);
+        return response;
+    }
+    // #endregion
+    // #region "PUT"
+    async update(id, data) {
+        const url = this.resolveURL(id);
+        const response = await this.PUT(url, data);
+        return response;
+    }
+    // #endregion
+    // #region "DELETE"
+    async delete(id) {
+        const url = this.resolveURL(id.toString());
+        const response = await this.DELETE(url);
+        return response;
+    }
+}
+export { OrganizationService };

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

@@ -0,0 +1,13 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { GGEZGiftRewards, PromotionDetails } from "../../types";
+declare class PromotionService extends BaseService {
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    getPromotionByCode(promotionCode: string): Promise<import("axios").AxiosResponse<PromotionDetails, any, {}>>;
+    getTwitterSpotlightPostIds(): Promise<import("axios").AxiosResponse<string[], any, {}>>;
+    incrementPromotionParticipants(data: GGEZGiftRewards): Promise<import("axios").AxiosResponse<{
+        message: string;
+    }, any, {}>>;
+}
+export { PromotionService };

package/dist/api/services/promotion.js

@@ -0,0 +1,24 @@
+import { Endpoints } from "../../constants";
+import { BaseService } from "./base";
+class PromotionService extends BaseService {
+    constructor(config) {
+        super(config);
+        this.endpoint = Endpoints.Promotion;
+    }
+    // #region "GET"
+    async getPromotionByCode(promotionCode) {
+        const url = this.resolveURL(`/${promotionCode}`);
+        return this.GET(url);
+    }
+    async getTwitterSpotlightPostIds() {
+        const url = this.resolveURL("/spotlight/twitter");
+        return this.GET(url);
+    }
+    // #endregion
+    // #region "PUT"
+    async incrementPromotionParticipants(data) {
+        const url = this.resolveURL();
+        return this.PUT(url, data);
+    }
+}
+export { PromotionService };

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

@@ -0,0 +1,10 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { TransactionData, TransactionInquiry } from "../../types";
+declare class TransactionService extends BaseService {
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    inquiry(payload: TransactionInquiry): Promise<import("axios").AxiosResponse<TransactionInquiry, any, {}>>;
+    create(payload: TransactionData): Promise<import("axios").AxiosResponse<TransactionData, any, {}>>;
+}
+export { TransactionService };

package/dist/api/services/transaction.js

@@ -0,0 +1,31 @@
+import { Endpoints } from "../../constants";
+import { BaseService } from "./base";
+import { IPAddressAndLocationService } from "..";
+import { GeoHelper } from "../../helper";
+import { AxiosHelper } from "../../helper";
+class TransactionService extends BaseService {
+    constructor(config) {
+        super(config);
+        this.endpoint = Endpoints.Transaction;
+        this.axiosInstance.interceptors.request.use(async (req) => {
+            const locationService = new IPAddressAndLocationService(config);
+            const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
+            AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
+            return req;
+        });
+    }
+    // #region "GET"
+    async inquiry(payload) {
+        const url = this.resolveURL("/inquiry");
+        const response = await this.GET(url, payload);
+        return response;
+    }
+    // #endregion
+    // #region "POST"
+    async create(payload) {
+        const url = this.resolveURL();
+        const response = await this.POST(url, payload);
+        return response;
+    }
+}
+export { TransactionService };

package/dist/api/services/user.d.ts

@@ -0,0 +1,72 @@
+import { AxiosRequestConfig } from "axios";
+import { BaseService } from "./base";
+import type { ConfirmUserSecurity, DocumentData, ResetUserSecurity, UserData, ValidateUserSecurity, VerifyUserSecurity } from "../../types";
+declare class UserService extends BaseService {
+    url: string;
+    endpoint: string;
+    constructor(config: AxiosRequestConfig);
+    getUser(userId: number, token?: string): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getTermsAndConditions(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getSecurity(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getPhone(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getPreferences(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getPersonalInfo(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getLatestHistory(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getIdentification(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getHistory(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getGroup(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getExternalAuth(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getEmail(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getDocuments(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getCurrency(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getCreditCard(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getBankAccount(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getAddress(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getAccount(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getDeviceHistory(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    getActivity(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createUser(payload: UserData, config: AxiosRequestConfig): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createPhone(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createDevice(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createIdentification(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createExternalAuth(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createEmail(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createCurrency(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createCreditCard(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createBankAccount(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createAddress(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    createTicket(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    securityAccess(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    uploadDocument(userId: number, payload: DocumentData): Promise<import("axios").AxiosResponse<DocumentData, any, {}>>;
+    confirmSecurityData(userId: number, payload: ConfirmUserSecurity): Promise<import("axios").AxiosResponse<ConfirmUserSecurity, any, {}>>;
+    validateSecurityData(userId: number, payload: ValidateUserSecurity): Promise<import("axios").AxiosResponse<ValidateUserSecurity, any, {}>>;
+    verifySecurityData(userId: number, payload: VerifyUserSecurity): Promise<import("axios").AxiosResponse<VerifyUserSecurity, any, {}>>;
+    resetSecurityData(userId: number, payload: ResetUserSecurity): Promise<import("axios").AxiosResponse<ResetUserSecurity, any, {}>>;
+    enrollGoogleAuth(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    activateGoogleAuth(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deactivateGoogleAuth(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteGoogleAuth(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateUser(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateSecurity(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updatePreferences(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateDevice(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    logoutDevice(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updatePhone(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updatePersonalInfo(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateIdentification(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateExternalAuth(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateEmail(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateCreditCard(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateBankAccount(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    updateAddress(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteUser(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteCreditCard(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteAddress(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteDevice(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteBankAccount(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteIdentification(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteEmail(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deletePhone(userId: number, payload: UserData): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+    deleteExternalAuth(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
+}
+export { UserService };