ggez-banking-sdk 0.1.81 → 0.1.87

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

@@ -0,0 +1,19 @@
+import type { AccountClientData } from "../../types";
+declare class AccountClient {
+    private readonly clientData;
+    private accountService;
+    constructor(clientData: AccountClientData);
+    Get: (accountId: number) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    GetLimits: (accountId: number) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { AccountClient };

package/dist/api/clients/account.js

@@ -0,0 +1,31 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { AccountService } from "../services";
+class AccountClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "GET"
+        this.Get = async (accountId) => {
+            try {
+                const response = await this.accountService.get(accountId);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "account", "getAccount", "getAccount");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.GetLimits = async (accountId) => {
+            try {
+                const response = await this.accountService.getLimits(accountId);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "account", "getAccountLimit", "getAccountLimit");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { token, baseUrl, lang, installationId } = clientData;
+        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        this.accountService = new AccountService(config);
+    }
+}
+export { AccountClient };

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

@@ -0,0 +1,32 @@
+import type { AuthClientData, IGenerateLimitedTokenData, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
+declare class AuthClient {
+    private readonly clientData;
+    private programId;
+    private authService;
+    constructor(clientData: AuthClientData);
+    LoginUserCredentials: (data: ILoginUserCredentialsData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    LoginDeviceCredentials: (data: ILoginDeviceCredentialsData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    LoginGoogleCredentials: (data: ILoginGoogleCredentialsData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    GenerateLimitedToken: (data: IGenerateLimitedTokenData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { AuthClient };

package/dist/api/clients/auth.js

@@ -0,0 +1,55 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { FillGenerateLimitedTokenData, FillLoginDeviceCredentialsData, FillLoginGoogleCredentialsData, FillLoginUserCredentialsData, } from "../data";
+import { AuthService } from "../services";
+class AuthClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "POST"
+        this.LoginUserCredentials = async (data) => {
+            try {
+                const credentialsData = FillLoginUserCredentialsData(this.programId, data);
+                const response = await this.authService.login(credentialsData);
+                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginUserCredentials");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.LoginDeviceCredentials = async (data) => {
+            try {
+                const credentialsData = FillLoginDeviceCredentialsData(this.programId, data);
+                const response = await this.authService.login(credentialsData);
+                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginDeviceCredentials");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.LoginGoogleCredentials = async (data) => {
+            try {
+                const credentialsData = FillLoginGoogleCredentialsData(this.programId, data);
+                const response = await this.authService.login(credentialsData);
+                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginGoogleCredentials");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.GenerateLimitedToken = async (data) => {
+            try {
+                const _data = FillGenerateLimitedTokenData(data);
+                const response = await this.authService.generateLimitedToken(_data);
+                return ResponseHelper.GetSuccessResponse(response, {}, "security", "generateLimitedToken");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { baseUrl, nodeUrl, lang, programId } = this.clientData;
+        const config = AxiosHelper.GetAuthAxiosConfig(baseUrl, lang, "");
+        this.authService = new AuthService(config, nodeUrl);
+        this.programId = programId;
+    }
+}
+export { AuthClient };

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

@@ -0,0 +1,31 @@
+import type { BlockchainClientData, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types/api";
+declare class BlockchainClient {
+    private readonly clientData;
+    private blockchainService;
+    constructor(clientData: BlockchainClientData);
+    Send: (data: IBlockchainSendRequestData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    MultiSend: (data: IBlockchainMultiSendRequestData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    Delegate: (data: IBlockchainDelegateRequestData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    Undelegate: (data: IBlockchainUndelegateRequestData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { BlockchainClient };

package/dist/api/clients/blockchain.js

@@ -0,0 +1,54 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { FillBlockchainDelegateData, FillBlockchainMultiSendData, FillBlockchainSendData, FillBlockchainUndelegateData, } from "../data/blockchain";
+import { BlockchainService } from "../services/blockchain";
+class BlockchainClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "POST"
+        this.Send = async (data) => {
+            try {
+                const blockchainSendData = FillBlockchainSendData(data);
+                const response = await this.blockchainService.send(blockchainSendData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "send", "SendRequest", "send");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.MultiSend = async (data) => {
+            try {
+                const blockchainMultiSendData = FillBlockchainMultiSendData(data);
+                const response = await this.blockchainService.multiSend(blockchainMultiSendData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "multiSend", "MultiSendRequest", "multiSend");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.Delegate = async (data) => {
+            try {
+                const blockchainDelegateData = FillBlockchainDelegateData(data);
+                const response = await this.blockchainService.delegate(blockchainDelegateData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "delegate", "DelegateRequest", "delegate");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.Undelegate = async (data) => {
+            try {
+                const blockchainUndelegateData = FillBlockchainUndelegateData(data);
+                const response = await this.blockchainService.undelegate(blockchainUndelegateData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "undelegate", "UndelegateRequest", "undelegate");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { token, baseUrl, lang, installationId } = clientData;
+        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        this.blockchainService = new BlockchainService(config);
+    }
+}
+export { BlockchainClient };

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

@@ -0,0 +1,10 @@
+export * from "./account";
+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/clients/index.js

@@ -0,0 +1,10 @@
+export * from "./account";
+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/clients/ipAddressAndLocation.d.ts

@@ -0,0 +1,13 @@
+import { IPAddressAndLocationClientData } from "../../types";
+declare class IPAddressAndLocationClient {
+    private readonly clientData;
+    private ipAddressAndLocationService;
+    constructor(clientData: IPAddressAndLocationClientData);
+    GetGeoCoordinates: () => Promise<import("../../types").GeoCoordinates>;
+    GetIPAddress: () => Promise<string>;
+    GetGeoCoordinatesAndIPAddress: () => Promise<{
+        geo_coordinates: import("../../types").GeoCoordinates;
+        ip_address: string;
+    }>;
+}
+export { IPAddressAndLocationClient };

package/dist/api/clients/ipAddressAndLocation.js

@@ -0,0 +1,24 @@
+import { IPAddressAndLocationService } from "../services";
+import { AxiosHelper, GeoHelper } from "../../helper";
+class IPAddressAndLocationClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "GET"
+        this.GetGeoCoordinates = async () => {
+            const data = await GeoHelper.GetGeoCoordinates(this.ipAddressAndLocationService);
+            return data;
+        };
+        this.GetIPAddress = async () => {
+            const data = await GeoHelper.GetIPAddress(this.ipAddressAndLocationService);
+            return data;
+        };
+        this.GetGeoCoordinatesAndIPAddress = async () => {
+            const data = await GeoHelper.GetGeoCoordinatesAndIPAddress(this.ipAddressAndLocationService);
+            return data;
+        };
+        const { token, baseUrl, lang, installationId } = clientData;
+        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        this.ipAddressAndLocationService = new IPAddressAndLocationService(config);
+    }
+}
+export { IPAddressAndLocationClient };

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

@@ -0,0 +1,55 @@
+import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, LimitedClientData, IValidateForgetPasswordData, IConfirmForgetPasswordData } from "../../types";
+declare class LimitedClient {
+    private readonly clientData;
+    private limitedService;
+    constructor(clientData: LimitedClientData);
+    ValidateForgetPassword: (data: IValidateForgetPasswordData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    ConfirmForgetPassword: (data: IConfirmForgetPasswordData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    ValidateEmail: (data: IValidateEmailData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    ValidatePhone: (data: IValidatePhoneData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    VerifyEmail: (data: IVerifyEmailData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    VerifyPhone: (data: IVerifyPhoneData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    ConfirmEmail: (data: IConfirmEmailData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    ConfirmPhone: (data: IConfirmPhoneData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { LimitedClient };

package/dist/api/clients/limited.js

@@ -0,0 +1,94 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { FillConfirmEmailData, FillConfirmForgetPasswordData, FillConfirmPhoneData, FillValidateEmailData, FillValidateForgetPasswordData, FillValidatePhoneData, FillVerifyEmailData, FillVerifyPhoneData, } from "../data";
+import { LimitedService } from "../services";
+class LimitedClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "POST"
+        this.ValidateForgetPassword = async (data) => {
+            try {
+                const forgetSecurityData = FillValidateForgetPasswordData(data);
+                const response = await this.limitedService.validateForgetSecurityData(forgetSecurityData);
+                return ResponseHelper.GetSuccessResponse(response, {}, "", "validateForgetPassword", "validate");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.ConfirmForgetPassword = async (data) => {
+            try {
+                const forgetSecurityData = FillConfirmForgetPasswordData(data);
+                const response = await this.limitedService.confirmForgetSecurityData(forgetSecurityData);
+                return ResponseHelper.GetSuccessResponse(response, {}, "", "confirmForgetPassword");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.ValidateEmail = async (data) => {
+            try {
+                const validateLimitedSecurity = FillValidateEmailData(data);
+                const response = await this.limitedService.validateSecurityData(validateLimitedSecurity);
+                return ResponseHelper.GetSuccessResponse(response, {}, "email", "validateEmail", "validate");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.ValidatePhone = async (data) => {
+            try {
+                const validateLimitedSecurity = FillValidatePhoneData(data);
+                const response = await this.limitedService.validateSecurityData(validateLimitedSecurity);
+                return ResponseHelper.GetSuccessResponse(response, {}, "phone", "validatePhone", "validate");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.VerifyEmail = async (data) => {
+            try {
+                const verifyUserSecurity = FillVerifyEmailData(data);
+                const response = await this.limitedService.verifySecurityData(verifyUserSecurity);
+                return ResponseHelper.GetSuccessResponse(response, {}, "email", "verifyEmail", "verify");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.VerifyPhone = async (data) => {
+            try {
+                const verifyUserSecurity = FillVerifyPhoneData(data);
+                const response = await this.limitedService.verifySecurityData(verifyUserSecurity);
+                return ResponseHelper.GetSuccessResponse(response, {}, "phone", "verifyPhone", "verify");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.ConfirmEmail = async (data) => {
+            try {
+                const confirmUserSecurity = FillConfirmEmailData(data);
+                const response = await this.limitedService.confirmSecurityData(confirmUserSecurity);
+                return ResponseHelper.GetSuccessResponse(response, {}, "email", "confirmEmail");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.ConfirmPhone = async (data) => {
+            try {
+                const confirmUserSecurity = FillConfirmPhoneData(data);
+                const response = await this.limitedService.confirmSecurityData(confirmUserSecurity);
+                return ResponseHelper.GetSuccessResponse(response, {}, "phone", "confirmPhone");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { token, baseUrl, nodeUrl, lang } = this.clientData;
+        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang);
+        this.limitedService = new LimitedService(config, nodeUrl);
+    }
+}
+export { LimitedClient };

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

@@ -0,0 +1,13 @@
+import { ICreateOrderData, OrderClientData } from "../../types";
+declare class OrderClient {
+    private readonly clientData;
+    private orderService;
+    constructor(clientData: OrderClientData);
+    CreateOrder: (data: ICreateOrderData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { OrderClient };

package/dist/api/clients/order.js

@@ -0,0 +1,24 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { FillCreateOrderData } from "../data/order";
+import { OrderService } from "../services";
+class OrderClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "POST"
+        this.CreateOrder = async (data) => {
+            try {
+                const createOrderData = FillCreateOrderData(data);
+                const response = await this.orderService.create(createOrderData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "order", "OrderRequest", "OrderRequest");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { token, baseUrl, lang, installationId } = clientData;
+        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        this.orderService = new OrderService(config);
+    }
+}
+export { OrderClient };

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

@@ -0,0 +1,33 @@
+import type { OrganizationClientData } from "../../types";
+import type { ICreateOrganizationData, IUpdateOrganizationData, ICreateOrganizationDocumentData } from "../../types";
+declare class OrganizationClient {
+    private readonly clientData;
+    private organizationService;
+    private userId;
+    constructor(clientData: OrganizationClientData);
+    CreateOrganization: (data: ICreateOrganizationData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    CreateOrganizationDocument: (id: string, data: ICreateOrganizationDocumentData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    UpdateOrganization: (id: string, data: IUpdateOrganizationData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    DeleteOrganization: (id: number) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { OrganizationClient };

package/dist/api/clients/organization.js

@@ -0,0 +1,58 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { FillCreateOrganizationData, FillCreateOrganizationDocumentData, FillUpdateOrganizationData, } from "../data/organization";
+import { OrganizationService } from "../services";
+class OrganizationClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "POST"
+        this.CreateOrganization = async (data) => {
+            try {
+                const organizationData = FillCreateOrganizationData(data, this.userId);
+                const response = await this.organizationService.create(organizationData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "organization", "CreateOrganization", "createOrganization");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.CreateOrganizationDocument = async (id, data) => {
+            try {
+                const documentData = FillCreateOrganizationDocumentData(data);
+                const response = await this.organizationService.createDocument(id, documentData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "organization", "CreateDocumentOrganization", "createDocumentOrganization");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        // #endregion
+        // #region "PUT"
+        this.UpdateOrganization = async (id, data) => {
+            try {
+                const organizationData = FillUpdateOrganizationData(data, this.userId);
+                const response = await this.organizationService.update(id, organizationData);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "organization", "UpdateOrganization", "updateOrganization");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        // #endregion
+        // #region "DELETE"
+        this.DeleteOrganization = async (id) => {
+            try {
+                const response = await this.organizationService.delete(id);
+                return ResponseHelper.GetSuccessResponse(response, this.clientData.userInfo, "organization", "DeleteOrganization", "deleteOrganization");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { token, baseUrl, userId, lang, installationId } = clientData;
+        const config = AxiosHelper.GetAxiosConfig(token, baseUrl, lang, installationId);
+        this.organizationService = new OrganizationService(config);
+        this.userId = userId;
+    }
+}
+export { OrganizationClient };

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

@@ -0,0 +1,25 @@
+import type { GGEZGiftRewards, PromotionClientData } from "../../types";
+declare class PromotionClient {
+    private readonly clientData;
+    private promotionService;
+    constructor(clientData: PromotionClientData);
+    GetPromotionByCode: (code: string) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    GetTwitterSpotlightPostIds: () => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    IncrementPromotionParticipants: (data: GGEZGiftRewards) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { PromotionClient };

package/dist/api/clients/promotion.js

@@ -0,0 +1,42 @@
+import { AxiosHelper } from "../../helper";
+import { ResponseHelper } from "../../helper";
+import { PromotionService } from "../services";
+class PromotionClient {
+    constructor(clientData) {
+        this.clientData = clientData;
+        // #region "GET"
+        this.GetPromotionByCode = async (code) => {
+            try {
+                const response = await this.promotionService.getPromotionByCode(code);
+                return ResponseHelper.GetSuccessResponse(response, {}, "", "getPromotionByCode");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        this.GetTwitterSpotlightPostIds = async () => {
+            try {
+                const response = await this.promotionService.getTwitterSpotlightPostIds();
+                return ResponseHelper.GetSuccessResponse(response, {}, "", "getTwitterSpotlightPostIds");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        // #endregion
+        // #region "PUT"
+        this.IncrementPromotionParticipants = async (data) => {
+            try {
+                const response = await this.promotionService.incrementPromotionParticipants(data);
+                return ResponseHelper.GetSuccessResponse(response, {}, "security", "loginGoogleCredentials");
+            }
+            catch (error) {
+                return ResponseHelper.GetErrorResponse(error);
+            }
+        };
+        const { nodeUrl, lang } = this.clientData;
+        const config = AxiosHelper.GetAuthAxiosConfig(nodeUrl, lang, "");
+        this.promotionService = new PromotionService(config);
+    }
+}
+export { PromotionClient };

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

@@ -0,0 +1,19 @@
+import type { ICreateTransactionData, IInquiryTransactionData, TransactionClientData } from "../../types";
+declare class TransactionClient {
+    private readonly clientData;
+    private transactionService;
+    constructor(clientData: TransactionClientData);
+    InquiryTransaction: (params: IInquiryTransactionData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+    CreateTransaction: (data: ICreateTransactionData) => Promise<{
+        response: any;
+        status: string;
+        newUser: any;
+        message: any;
+    }>;
+}
+export { TransactionClient };