web3-banking-system-sdk 1.0.0

package/dist/api/service/limitedService.d.ts

@@ -0,0 +1,15 @@
+import { BaseService } from "./baseService";
+import type { ConfirmUserSecurity, ForgetSecurityData, ValidateLimitedSecurity, VerifyUserSecurity, LimitedServiceParameters } from "../../types";
+declare class LimitedService extends BaseService {
+    protected endpoint: string;
+    private authService;
+    constructor(data: LimitedServiceParameters);
+    private onLimitedRequest;
+    validateSecurityData(data: ValidateLimitedSecurity): Promise<import("../..").ApiResponse<ValidateLimitedSecurity>>;
+    verifySecurityData(data: VerifyUserSecurity): Promise<import("../..").ApiResponse<VerifyUserSecurity>>;
+    confirmSecurityData(data: ConfirmUserSecurity): Promise<import("../..").ApiResponse<ConfirmUserSecurity>>;
+    checkForgetSecurityData(data: ForgetSecurityData): Promise<import("../..").ApiResponse<ForgetSecurityData>>;
+    validateForgetSecurityData(data: ForgetSecurityData): Promise<import("../..").ApiResponse<ForgetSecurityData>>;
+    confirmForgetSecurityData(data: ForgetSecurityData): Promise<import("../..").ApiResponse<ForgetSecurityData>>;
+}
+export { LimitedService };

package/dist/api/service/limitedService.js

@@ -0,0 +1,47 @@
+import { Endpoints, LimitedEndpoints } from "../../constant/constant";
+import { AxiosHelper } from "../../helper/api/axiosHelper";
+import { AuthService } from "./authService";
+import { BaseService } from "./baseService";
+class LimitedService extends BaseService {
+    endpoint = Endpoints.Limited;
+    authService;
+    constructor(data) {
+        super(data);
+        this.authService = new AuthService(data);
+        this.axiosInstance.interceptors.request.use((req) => this.onLimitedRequest(req));
+    }
+    // #region "Interceptors Handlers"
+    async onLimitedRequest(req) {
+        await AxiosHelper.injectLimitedToken(req, this.authService, this.cookiesHelper);
+        return req;
+    }
+    // #endregion
+    // #region "POST"
+    validateSecurityData(data) {
+        const url = this.resolveURL(LimitedEndpoints.SecurityValidate);
+        return this.POST(url, data);
+    }
+    verifySecurityData(data) {
+        const url = this.resolveURL(LimitedEndpoints.SecurityVerify);
+        return this.POST(url, data, {
+            flags: { showSensitiveData: true },
+        });
+    }
+    confirmSecurityData(data) {
+        const url = this.resolveURL(LimitedEndpoints.SecurityConfirm);
+        return this.POST(url, data);
+    }
+    checkForgetSecurityData(data) {
+        const url = this.resolveURL(LimitedEndpoints.SecurityForgetCheck);
+        return this.POST(url, data);
+    }
+    validateForgetSecurityData(data) {
+        const url = this.resolveURL(LimitedEndpoints.SecurityForgetValidate);
+        return this.POST(url, data);
+    }
+    confirmForgetSecurityData(data) {
+        const url = this.resolveURL(LimitedEndpoints.SecurityForgetConfirm);
+        return this.POST(url, data);
+    }
+}
+export { LimitedService };

package/dist/api/service/orderService.d.ts

@@ -0,0 +1,8 @@
+import { BaseService } from "./baseService";
+import type { OrderData, OrderServiceParameters } from "../../types";
+declare class OrderService extends BaseService {
+    protected endpoint: string;
+    constructor(data: OrderServiceParameters);
+    create(data: OrderData): Promise<import("../..").ApiResponse<OrderData>>;
+}
+export { OrderService };

package/dist/api/service/orderService.js

@@ -0,0 +1,14 @@
+import { Endpoints } from "../../constant/constant";
+import { BaseService } from "./baseService";
+class OrderService extends BaseService {
+    endpoint = Endpoints.Order;
+    constructor(data) {
+        super(data);
+    }
+    // #region "POST"
+    create(data) {
+        const url = this.resolveURL();
+        return this.POST(url, data);
+    }
+}
+export { OrderService };

package/dist/api/service/organizationService.d.ts

@@ -0,0 +1,12 @@
+import { BaseService } from "./baseService";
+import type { DocumentData, OrganizationData, OrganizationServiceParameters } from "../../types";
+declare class OrganizationService extends BaseService {
+    protected endpoint: string;
+    constructor(data: OrganizationServiceParameters);
+    get(id: number): Promise<import("../..").ApiResponse<OrganizationData>>;
+    create(data: OrganizationData): Promise<import("../..").ApiResponse<OrganizationData>>;
+    createDocument(id: number, data: DocumentData): Promise<import("../..").ApiResponse<DocumentData>>;
+    update(id: number, data: OrganizationData): Promise<import("../..").ApiResponse<OrganizationData>>;
+    delete(id: number): Promise<import("../..").ApiResponse<OrganizationData>>;
+}
+export { OrganizationService };

package/dist/api/service/organizationService.js

@@ -0,0 +1,35 @@
+import { Endpoints, OrganizationEndpoints } from "../../constant/constant";
+import { BaseService } from "./baseService";
+class OrganizationService extends BaseService {
+    endpoint = Endpoints.Organization;
+    constructor(data) {
+        super(data);
+    }
+    // #region "GET"
+    get(id) {
+        const url = this.resolveURL(id);
+        return this.GET(url, { flags: { showSensitiveData: true } });
+    }
+    // #region "POST"
+    create(data) {
+        const url = this.resolveURL();
+        return this.POST(url, data);
+    }
+    createDocument(id, data) {
+        const url = this.resolveURL(`${OrganizationEndpoints.Document}/${id}`);
+        return this.POST(url, data);
+    }
+    // #endregion
+    // #region "PUT"
+    update(id, data) {
+        const url = this.resolveURL(id);
+        return this.PUT(url, data);
+    }
+    // #endregion
+    // #region "DELETE"
+    delete(id) {
+        const url = this.resolveURL(id);
+        return this.DELETE(url);
+    }
+}
+export { OrganizationService };

package/dist/api/service/programService.d.ts

@@ -0,0 +1,15 @@
+import { BaseService } from "./baseService";
+import type { ProgramServiceParameter } from "../../types";
+import type { ProgramData, SignupRequirements } from "../../types/banking/program";
+declare class ProgramService extends BaseService {
+    protected endpoint: string;
+    private authService;
+    constructor(data: ProgramServiceParameter);
+    private onProgramRequest;
+    get(): Promise<import("../..").ApiResponse<ProgramData>>;
+    getSystemFeatures(): Promise<import("../..").ApiResponse<ProgramData>>;
+    getBin(): Promise<import("../..").ApiResponse<ProgramData>>;
+    getSignUp(): Promise<import("../..").ApiResponse<SignupRequirements>>;
+    getProgramSecurity(): Promise<import("../..").ApiResponse<ProgramData>>;
+}
+export { ProgramService };

package/dist/api/service/programService.js

@@ -0,0 +1,40 @@
+import { BaseService } from "./baseService";
+import { Endpoints, ProgramEndpoints } from "../../constant/constant";
+import { AxiosHelper } from "../../helper";
+import { AuthService } from "./authService";
+class ProgramService extends BaseService {
+    endpoint = Endpoints.Program;
+    authService;
+    constructor(data) {
+        super(data);
+        this.authService = new AuthService(data);
+        this.axiosInstance.interceptors.request.use((req) => this.onProgramRequest(req));
+    }
+    // #region "Interceptors Handlers"
+    async onProgramRequest(req) {
+        await AxiosHelper.injectLimitedToken(req, this.authService, this.cookiesHelper);
+        return req;
+    }
+    //#region "GET"
+    get() {
+        const url = this.resolveURL(this.context.getProgramId());
+        return this.GET(url);
+    }
+    getSystemFeatures() {
+        const url = this.resolveURL(`${ProgramEndpoints.SystemFeatures}/${this.context.getProgramId()}`);
+        return this.GET(url);
+    }
+    getBin() {
+        const url = this.resolveURL(`${ProgramEndpoints.Bin}/${this.context.getProgramId()}`);
+        return this.GET(url);
+    }
+    getSignUp() {
+        const url = this.resolveURL(`${ProgramEndpoints.SignUp}/${this.context.getProgramId()}`);
+        return this.GET(url);
+    }
+    getProgramSecurity() {
+        const url = this.resolveURL(`${ProgramEndpoints.ProgramSecurity}/${this.context.getProgramId()}`);
+        return this.GET(url);
+    }
+}
+export { ProgramService };

package/dist/api/service/promotionService.d.ts

@@ -0,0 +1,10 @@
+import { BaseService } from "./baseService";
+import type { GGEZGiftRewards, PromotionDetails, PromotionIncrementResult, PromotionServiceParameters, TwitterSpotlightPostIdsResult } from "../../types";
+declare class PromotionService extends BaseService {
+    protected endpoint: string;
+    constructor(data: PromotionServiceParameters);
+    getPromotionByCode(promotionCode: string): Promise<import("../..").ApiResponse<PromotionDetails>>;
+    getTwitterSpotlightPostIds(): Promise<import("../..").ApiResponse<TwitterSpotlightPostIdsResult>>;
+    incrementPromotionParticipants(data: GGEZGiftRewards): Promise<import("../..").ApiResponse<PromotionIncrementResult>>;
+}
+export { PromotionService };

package/dist/api/service/promotionService.js

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

package/dist/api/service/transactionService.d.ts

@@ -0,0 +1,12 @@
+import { BaseService } from "./baseService";
+import type { TransactionData } from "../../types/banking/transaction/transactionData";
+import type { TransactionInquiry } from "../../types/banking/transaction/transactionInquiry";
+import type { TransactionResultInquiry } from "../../types/banking/transaction/transactionResultInquiry";
+import type { TransactionServiceParameters } from "../../types/api/service/transactionService";
+declare class TransactionService extends BaseService {
+    protected endpoint: string;
+    constructor(data: TransactionServiceParameters);
+    inquiry(payload: TransactionInquiry): Promise<import("../..").ApiResponse<TransactionResultInquiry>>;
+    create(payload: TransactionData): Promise<import("../..").ApiResponse<TransactionData>>;
+}
+export { TransactionService };

package/dist/api/service/transactionService.js

@@ -0,0 +1,20 @@
+import { Endpoints, TransactionEndpoints } from "../../constant/constant";
+import { BaseService } from "./baseService";
+class TransactionService extends BaseService {
+    endpoint = Endpoints.Transaction;
+    constructor(data) {
+        super(data);
+    }
+    // #region "GET"
+    inquiry(payload) {
+        const url = this.resolveURL(TransactionEndpoints.Inquiry);
+        return this.GET(url, { params: payload });
+    }
+    // #endregion
+    // #region "POST"
+    create(payload) {
+        const url = this.resolveURL();
+        return this.POST(url, payload);
+    }
+}
+export { TransactionService };

package/dist/api/service/userService.d.ts

@@ -0,0 +1,79 @@
+import { BaseService } from "./baseService";
+import type { ConfirmUserSecurity } from "../../types/banking/user/confirmUserSecurity";
+import type { DocumentData } from "../../types/banking/user/documentdata";
+import type { ResetUserSecurity } from "../../types/banking/user/resetUserSecurity";
+import type { UserData } from "../../types/banking/user/userdata";
+import type { UserServiceParameters } from "../../types/api/service/userService";
+import type { ValidateUserSecurity } from "../../types/banking/user/validateUserSecurity";
+import type { VerifyUserSecurity } from "../../types/banking/user/verifyUserSecurity";
+declare class UserService extends BaseService {
+    protected endpoint: string;
+    private authService;
+    constructor(data: UserServiceParameters);
+    private userId;
+    getUser(): Promise<import("../..").ApiResponse<UserData>>;
+    getTermsAndConditions(): Promise<import("../..").ApiResponse<UserData>>;
+    getSecurity(): Promise<import("../..").ApiResponse<UserData>>;
+    getPhone(): Promise<import("../..").ApiResponse<UserData>>;
+    getPreferences(): Promise<import("../..").ApiResponse<UserData>>;
+    getPersonalInfo(): Promise<import("../..").ApiResponse<UserData>>;
+    getLatestHistory(): Promise<import("../..").ApiResponse<UserData>>;
+    getIdentification(): Promise<import("../..").ApiResponse<UserData>>;
+    getHistory(): Promise<import("../..").ApiResponse<UserData>>;
+    getGroup(): Promise<import("../..").ApiResponse<UserData>>;
+    getExternalAuth(): Promise<import("../..").ApiResponse<UserData>>;
+    getEmail(): Promise<import("../..").ApiResponse<UserData>>;
+    getDocuments(): Promise<import("../..").ApiResponse<UserData>>;
+    getCurrency(): Promise<import("../..").ApiResponse<UserData>>;
+    getCreditCard(): Promise<import("../..").ApiResponse<UserData>>;
+    getBankAccount(): Promise<import("../..").ApiResponse<UserData>>;
+    getAddress(): Promise<import("../..").ApiResponse<UserData>>;
+    getAccount(): Promise<import("../..").ApiResponse<UserData>>;
+    getDeviceHistory(): Promise<import("../..").ApiResponse<UserData>>;
+    getActivity(): Promise<import("../..").ApiResponse<UserData>>;
+    createUser(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createPhone(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createDevice(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createIdentification(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createExternalAuth(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createEmail(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createCurrency(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createCreditCard(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createBankAccount(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createAddress(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    createTicket(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    securityAccess(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    uploadDocument(payload: DocumentData): Promise<import("../..").ApiResponse<DocumentData>>;
+    confirmSecurityData(payload: ConfirmUserSecurity): Promise<import("../..").ApiResponse<ConfirmUserSecurity>>;
+    validateSecurityData(payload: ValidateUserSecurity): Promise<import("../..").ApiResponse<ValidateUserSecurity>>;
+    verifySecurityData(payload: VerifyUserSecurity): Promise<import("../..").ApiResponse<VerifyUserSecurity>>;
+    resetSecurityData(payload: ResetUserSecurity): Promise<import("../..").ApiResponse<ResetUserSecurity>>;
+    enrollGoogleAuth(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    activateGoogleAuth(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deactivateGoogleAuth(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteGoogleAuth(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateUser(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateSecurity(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updatePreferences(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateDevice(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    logoutDevice(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updatePhone(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updatePersonalInfo(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateIdentification(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateExternalAuth(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateEmail(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateCreditCard(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateBankAccount(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateAddress(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    updateUserType(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteUser(): Promise<import("../..").ApiResponse<UserData>>;
+    deleteCreditCard(): Promise<import("../..").ApiResponse<UserData>>;
+    deleteAddress(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteDevice(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteBankAccount(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteIdentification(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteEmail(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deletePhone(payload: UserData): Promise<import("../..").ApiResponse<UserData>>;
+    deleteExternalAuth(): Promise<import("../..").ApiResponse<UserData>>;
+}
+export { UserService };

package/dist/api/service/userService.js

@@ -0,0 +1,286 @@
+import { Endpoints, UserEndpoints } from "../../constant/constant";
+import { AuthService } from "./authService";
+import { AxiosHelper } from "../../helper/api/axiosHelper";
+import { BaseService } from "./baseService";
+class UserService extends BaseService {
+    endpoint = Endpoints.User;
+    authService;
+    constructor(data) {
+        super(data);
+        this.authService = new AuthService(data);
+    }
+    async userId() {
+        return await this.cookiesHelper.getUserId();
+    }
+    // #region "GET"
+    async getUser() {
+        const url = this.resolveURL(`/${await this.userId()}`);
+        return this.GET(url, {
+            flags: { showCustomField: true, showTicket: true },
+        });
+    }
+    async getTermsAndConditions() {
+        const url = this.resolveURL(`${UserEndpoints.TermsAndConditions}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getSecurity() {
+        const url = this.resolveURL(`${UserEndpoints.Security}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getPhone() {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getPreferences() {
+        const url = this.resolveURL(`${UserEndpoints.Preferences}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getPersonalInfo() {
+        const url = this.resolveURL(`${UserEndpoints.PersonalInfo}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getLatestHistory() {
+        const url = this.resolveURL(`${UserEndpoints.HistoryLatest}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getIdentification() {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
+        return this.GET(url, { flags: { showSensitiveData: true } });
+    }
+    async getHistory() {
+        const url = this.resolveURL(`${UserEndpoints.HistoryLatest}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getGroup() {
+        const url = this.resolveURL(`${UserEndpoints.Group}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getExternalAuth() {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getEmail() {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getDocuments() {
+        const url = this.resolveURL(`${UserEndpoints.Documents}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getCurrency() {
+        const url = this.resolveURL(`${UserEndpoints.Currency}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getCreditCard() {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getBankAccount() {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
+        return this.GET(url, { flags: { showSensitiveData: true } });
+    }
+    async getAddress() {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
+        return this.GET(url, { flags: { showSensitiveData: true } });
+    }
+    async getAccount() {
+        const url = this.resolveURL(`${UserEndpoints.Account}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getDeviceHistory() {
+        const url = this.resolveURL(`${UserEndpoints.DeviceHistory}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    async getActivity() {
+        const url = this.resolveURL(`${UserEndpoints.Activity}/${await this.userId()}`);
+        return this.GET(url);
+    }
+    // #endregion
+    // #region "POST"
+    async createUser(payload) {
+        const url = this.resolveURL();
+        const headers = await AxiosHelper.getLimitedAuthHeaders(this.authService, this.cookiesHelper);
+        return this.POST(url, payload, { headers });
+    }
+    async createPhone(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
+        return this.POST(url, payload, {
+            flags: { checkPhoneVerification: true },
+        });
+    }
+    async createDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Device}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createIdentification(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createExternalAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createEmail(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createCurrency(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Currency}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createCreditCard(payload) {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createBankAccount(payload) {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createAddress(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async createTicket(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Ticket}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async securityAccess(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityAccess}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async uploadDocument(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Document}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async confirmSecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityConfirm}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async validateSecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityValidate}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async verifySecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityVerify}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async resetSecurityData(payload) {
+        const url = this.resolveURL(`${UserEndpoints.SecurityReset}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async enrollGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthEnroll}/${await this.userId()}`);
+        return this.POST(url, payload, {
+            flags: { showSensitiveData: true },
+        });
+    }
+    async activateGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthActivate}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async deactivateGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthDeactivate}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    async deleteGoogleAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.AuthDelete}/${await this.userId()}`);
+        return this.POST(url, payload);
+    }
+    // #endregion
+    // #region "PUT"
+    async updateUser(payload) {
+        const url = this.resolveURL(`/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateSecurity(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Security}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updatePreferences(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Preferences}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Device}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async logoutDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.DeviceLogout}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updatePhone(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updatePersonalInfo(payload) {
+        const url = this.resolveURL(`${UserEndpoints.PersonalInfo}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateIdentification(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateExternalAuth(payload) {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateEmail(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateCreditCard(payload) {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateBankAccount(payload) {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateAddress(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    async updateUserType(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Type}/${await this.userId()}`);
+        return this.PUT(url, payload);
+    }
+    // #endregion
+    // #region "DELETE"
+    async deleteUser() {
+        const url = this.resolveURL(`/${await this.userId()}`);
+        return this.DELETE(url);
+    }
+    async deleteCreditCard() {
+        const url = this.resolveURL(`${UserEndpoints.CreditCard}/${await this.userId()}`);
+        return this.DELETE(url);
+    }
+    async deleteAddress(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Address}/${await this.userId()}`);
+        return this.DELETE(url, { data: payload });
+    }
+    async deleteDevice(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Device}/${await this.userId()}`);
+        return this.DELETE(url, { data: payload });
+    }
+    async deleteBankAccount(payload) {
+        const url = this.resolveURL(`${UserEndpoints.BankAccount}/${await this.userId()}`);
+        return this.DELETE(url, { data: payload });
+    }
+    async deleteIdentification(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Identification}/${await this.userId()}`);
+        return this.DELETE(url, { data: payload });
+    }
+    async deleteEmail(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Email}/${await this.userId()}`);
+        return this.DELETE(url, { data: payload });
+    }
+    async deletePhone(payload) {
+        const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);
+        return this.DELETE(url, { data: payload });
+    }
+    async deleteExternalAuth() {
+        const url = this.resolveURL(`${UserEndpoints.ExternalAuth}/${await this.userId()}`);
+        return this.DELETE(url);
+    }
+}
+export { UserService };

package/dist/auth.d.ts

@@ -0,0 +1,5 @@
+export { AuthProxy } from "./api/proxy/authProxy";
+export { AuthService } from "./api/service/authService";
+export * from "./api/data/auth";
+export type * from "./types/api/data/auth";
+export type * from "./types/api/service/authService";

package/dist/auth.js

@@ -0,0 +1,5 @@
+// Auth-related exports - Complete auth domain
+export { AuthProxy } from "./api/proxy/authProxy";
+export { AuthService } from "./api/service/authService";
+// Auth data exports
+export * from "./api/data/auth";

package/dist/blockchain.d.ts

@@ -0,0 +1,8 @@
+export { BlockchainProxy } from "./api/proxy/blockchainProxy";
+export { BlockchainService } from "./api/service/blockchainService";
+export { BlockchainAPI } from "./api/bc-api";
+export * from "./api/data/blockchain";
+export type * from "./types/api/data/blockchain";
+export type * from "./types/api/service/blockchainService";
+export type * from "./types/api/bc-api";
+export type * from "./types/blockchain";