squarefi-bff-api-module 1.0.2 → 1.1.0

package/dist/api/auth.d.ts

@@ -5,23 +5,23 @@ export declare const refreshTokenPath = "/auth/refresh/refresh-token";
 export declare const auth: {
     otp: {
         verify: {
-            email: (email: string, token: string) => Promise<import("axios").AxiosResponse<API.Auth.VerifyOtp.Response, any>>;
-            phone: (phone: string, token: string) => Promise<import("axios").AxiosResponse<API.Auth.VerifyOtp.Response, any>>;
+            email: (email: string, token: string) => Promise<API.Auth.VerifyOtp.Response>;
+            phone: (phone: string, token: string) => Promise<API.Auth.VerifyOtp.Response>;
         };
     };
     signin: {
         omni: {
-            email: (data: API.Auth.SignIn.Email.OTP.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
-            phone: (data: API.Auth.SignIn.Phone.OTP.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
+            email: (data: API.Auth.SignIn.Email.OTP.Request) => Promise<unknown>;
+            phone: (data: API.Auth.SignIn.Phone.OTP.Request) => Promise<unknown>;
         };
-        telegram: (data: API.Auth.Telegram.Signin) => Promise<import("axios").AxiosResponse<API.Auth.Tokens, any>>;
-        password: (email: string, password: string) => Promise<import("axios").AxiosResponse<API.Auth.SupabaseGetSessionResponse, any>>;
+        telegram: (data: API.Auth.Telegram.Signin) => Promise<API.Auth.Tokens>;
+        password: (email: string, password: string) => Promise<API.Auth.SupabaseGetSessionResponse>;
     };
     signup: {
-        password: (email: string, password: string) => Promise<import("axios").AxiosResponse<API.Auth.SupabaseGetSessionResponse, any>>;
-        telegram: (data: API.Auth.Telegram.Signup) => Promise<import("axios").AxiosResponse<unknown, any>>;
+        password: (email: string, password: string) => Promise<API.Auth.SupabaseGetSessionResponse>;
+        telegram: (data: API.Auth.Telegram.Signup) => Promise<unknown>;
     };
     refresh: {
-        refresh_token: (refresh_token: string) => Promise<import("axios").AxiosResponse<API.Auth.Tokens, any>>;
+        refresh_token: (refresh_token: string) => Promise<API.Auth.Tokens>;
     };
 };

package/dist/api/developer.d.ts

@@ -1,12 +1,12 @@
 import { API } from './types';
 export declare const developer: {
     apiKeys: {
-        getAll: () => Promise<import("axios").AxiosResponse<API.Developer.ApiCode.ApiCode[], any>>;
-        create: (data: API.Developer.ApiCode.Create.Request) => Promise<import("axios").AxiosResponse<API.Developer.ApiCode.Create.Response, any>>;
-        rotate: (data: API.Developer.ApiCode.Rotate.Request) => Promise<import("axios").AxiosResponse<API.Developer.ApiCode.Rotate.Response, any>>;
-        update: (data: API.Developer.ApiCode.Update.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
+        getAll: () => Promise<API.Developer.ApiCode.ApiCode[]>;
+        create: (data: API.Developer.ApiCode.Create.Request) => Promise<API.Developer.ApiCode.Create.Response>;
+        rotate: (data: API.Developer.ApiCode.Rotate.Request) => Promise<API.Developer.ApiCode.Rotate.Response>;
+        update: (data: API.Developer.ApiCode.Update.Request) => Promise<unknown>;
     };
     vendors: {
-        list: () => Promise<import("axios").AxiosResponse<API.Developer.Vendors.Vendor[], any>>;
+        list: () => Promise<API.Developer.Vendors.Vendor[]>;
     };
 };

package/dist/api/exchange.js

@@ -4,15 +4,9 @@ exports.exchange = void 0;
 const apiClientFactory_1 = require("../utils/apiClientFactory");
 const constants_1 = require("../constants");
 const createOrderTypeMethods = (orderType) => ({
-    getByFromCurrency: (from_uuid) => apiClientFactory_1.apiClientV1
-        .getRequest('/exchange/', { params: { from_uuid, order_type: orderType } })
-        .then(({ data }) => data),
-    getByToCurrency: (to_uuid) => apiClientFactory_1.apiClientV1
-        .getRequest('/exchange/', { params: { to_uuid, order_type: orderType } })
-        .then(({ data }) => data),
-    getByOrderType: () => apiClientFactory_1.apiClientV1
-        .getRequest('/exchange/', { params: { order_type: orderType } })
-        .then(({ data }) => data),
+    getByFromCurrency: (from_uuid) => apiClientFactory_1.apiClientV1.getRequest('/exchange/', { params: { from_uuid, order_type: orderType } }),
+    getByToCurrency: (to_uuid) => apiClientFactory_1.apiClientV1.getRequest('/exchange/', { params: { to_uuid, order_type: orderType } }),
+    getByOrderType: () => apiClientFactory_1.apiClientV1.getRequest('/exchange/', { params: { order_type: orderType } }),
 });
 exports.exchange = {
     byOrderType: {

package/dist/api/fiat_accounts.d.ts

@@ -2,31 +2,31 @@ import { API } from './types';
 export declare const fiat_accounts_v2: {
     list: {
         withCards: {
-            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.FiatAccountsListWithCards, any>>;
+            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<API.FiatAccountsV2.FiatAccountsListWithCards>;
         };
         withoutCards: {
-            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.FiatAccountsListWithoutCards, any>>;
+            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<API.FiatAccountsV2.FiatAccountsListWithoutCards>;
         };
     };
-    getByUuid: ({ wallet_uuid, fiat_account_id }: API.FiatAccountsV2.ExtendedFiatAccount.Request) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.ExtendedFiatAccount.ExtendedFiatAccount, any>>;
-    create: ({ wallet_id, program_id }: API.FiatAccountsV2.CreateFiatAccount.Request) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.CreateFiatAccount.Response, any>>;
+    getByUuid: ({ wallet_uuid, fiat_account_id }: API.FiatAccountsV2.ExtendedFiatAccount.Request) => Promise<API.FiatAccountsV2.ExtendedFiatAccount.ExtendedFiatAccount>;
+    create: ({ wallet_id, program_id }: API.FiatAccountsV2.CreateFiatAccount.Request) => Promise<API.FiatAccountsV2.CreateFiatAccount.Response>;
     transactions: {
-        get: ({ fiat_account_id, wallet_uuid, limit, offset }: API.FiatAccountsV2.Transactions.TransactionList.Request) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.Transactions.TransactionList.Response, any>>;
+        get: ({ fiat_account_id, wallet_uuid, limit, offset }: API.FiatAccountsV2.Transactions.TransactionList.Request) => Promise<API.FiatAccountsV2.Transactions.TransactionList.Response>;
     };
 };
 export declare const fiat_accounts: {
     list: {
         withCards: {
-            getSinglecards: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccounts.FiatAccountWithCards[], any>>;
-            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccounts.FiatAccountWithCards[], any>>;
+            getSinglecards: (wallet_uuid: string, limit: number, offset: number) => Promise<API.FiatAccounts.FiatAccountWithCards[]>;
+            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<API.FiatAccounts.FiatAccountWithCards[]>;
         };
         withoutCards: {
-            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccounts.FiatAccount[], any>>;
+            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<API.FiatAccounts.FiatAccount[]>;
         };
     };
-    getByUuid: (uuid: string) => Promise<import("axios").AxiosResponse<API.FiatAccounts.FiatAccount, any>>;
-    create: (wallet_id: string, program_id: string) => Promise<import("axios").AxiosResponse<API.FiatAccounts.FiatAccount, any>>;
+    getByUuid: (uuid: string) => Promise<API.FiatAccounts.FiatAccount>;
+    create: (wallet_id: string, program_id: string) => Promise<API.FiatAccounts.FiatAccount>;
     transactions: {
-        get: (fiat_account_id: string, limit?: number, offset?: number) => Promise<import("axios").AxiosResponse<API.FiatAccounts.TransactionList, any>>;
+        get: (fiat_account_id: string, limit?: number, offset?: number) => Promise<API.FiatAccounts.TransactionList>;
     };
 };

package/dist/api/issuing.d.ts

@@ -1,27 +1,26 @@
-import { AxiosResponse } from 'axios';
 import { API } from './types';
 export declare const issuing: {
     cards: {
         create: {
-            standAloneCard: (data: API.Cards.Create.StandAloneRequest) => Promise<AxiosResponse<API.Cards.CardDetailItem, any>>;
-            fiatAccountCard: (data: API.Cards.Create.FiatAccountRequest) => Promise<AxiosResponse<API.Cards.CardDetailItem, any>>;
+            standAloneCard: (data: API.Cards.Create.StandAloneRequest) => Promise<API.Cards.CardDetailItem>;
+            fiatAccountCard: (data: API.Cards.Create.FiatAccountRequest) => Promise<API.Cards.CardDetailItem>;
         };
-        getByWalletUuid: (params: API.Cards.CardsList.Request.ByWalletUuid) => Promise<AxiosResponse<API.Cards.CardsList.Response, any>>;
-        getByFiatAccountAndWalletId: (params: API.Cards.CardsList.Request.ByFiatAccountAndWalletId) => Promise<AxiosResponse<API.Cards.CardsList.Response, any>>;
-        getById: (card_id: string) => Promise<AxiosResponse<API.Cards.CardDetailItem, any>>;
+        getByWalletUuid: (params: API.Cards.CardsList.Request.ByWalletUuid) => Promise<API.Cards.CardsList.Response>;
+        getByFiatAccountAndWalletId: (params: API.Cards.CardsList.Request.ByFiatAccountAndWalletId) => Promise<API.Cards.CardsList.Response>;
+        getById: (card_id: string) => Promise<API.Cards.CardDetailItem>;
         sensitiveData: {
-            get: (card_id: string) => Promise<AxiosResponse<API.Cards.SensitiveData, any>>;
+            get: (card_id: string) => Promise<API.Cards.SensitiveData>;
             otp: {
-                get: (card_id: string) => Promise<AxiosResponse<API.Cards.OTP, any>>;
+                get: (card_id: string) => Promise<API.Cards.OTP>;
             };
         };
-        close: (card_id: string) => Promise<AxiosResponse<any, any>>;
-        freeze: (card_id: string) => Promise<AxiosResponse<API.Cards.CardDetailItem, any>>;
-        unfreeze: (card_id: string) => Promise<AxiosResponse<API.Cards.CardDetailItem, any>>;
+        close: (card_id: string) => Promise<any>;
+        freeze: (card_id: string) => Promise<API.Cards.CardDetailItem>;
+        unfreeze: (card_id: string) => Promise<API.Cards.CardDetailItem>;
     };
     transactions: {
-        getByCardId: (card_id: string, limit?: number, offset?: number) => Promise<AxiosResponse<API.Cards.TransactionsList, any>>;
-        getByFiatAccountId: (fiat_account_id: string, limit?: number, offset?: number) => Promise<AxiosResponse<API.Cards.TransactionsList, any>>;
+        getByCardId: (card_id: string, limit?: number, offset?: number) => Promise<API.Cards.TransactionsList>;
+        getByFiatAccountId: (fiat_account_id: string, limit?: number, offset?: number) => Promise<API.Cards.TransactionsList>;
     };
     config: {
         programs: {

package/dist/api/issuing.js

@@ -8,17 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.issuing = void 0;
 const fiat_accounts_1 = require("./fiat_accounts");
@@ -33,13 +22,13 @@ exports.issuing = {
         getByWalletUuid: (params) => apiClientFactory_1.apiClientV1.getRequest('/issuing/cards', { params }),
         getByFiatAccountAndWalletId: (params) => apiClientFactory_1.apiClientV1.getRequest('/issuing/cards', { params }),
         getById: (card_id) => __awaiter(void 0, void 0, void 0, function* () {
-            const _a = yield apiClientFactory_1.apiClientV1.getRequest(`/issuing/cards/${card_id}`), { data: card } = _a, rest = __rest(_a, ["data"]);
-            const { data: fiatAccountData } = yield fiat_accounts_1.fiat_accounts.getByUuid(card.fiat_account.id);
+            const card = yield apiClientFactory_1.apiClientV1.getRequest(`/issuing/cards/${card_id}`);
+            const fiatAccountData = yield fiat_accounts_1.fiat_accounts.getByUuid(card.fiat_account.id);
             // const { data: fiatAccountData } = await fiat_accounts.getByUuid({ V2 API FIAT ACCOUNTS
             //   wallet_uuid: card.fiat_account.wallet_id,
             //   fiat_account_id: card.fiat_account.id,
             // });
-            return Object.assign(Object.assign({}, rest), { data: Object.assign(Object.assign({}, card), { fiat_account: Object.assign(Object.assign({}, fiatAccountData), { type: card.fiat_account.type }) }) });
+            return Object.assign(Object.assign({}, card), { fiat_account: Object.assign(Object.assign({}, fiatAccountData), { type: card.fiat_account.type }) });
         }),
         sensitiveData: {
             get: (card_id) => apiClientFactory_1.apiClientV1.getRequest(`/issuing/cards/${card_id}/sensitive`),
@@ -62,7 +51,7 @@ exports.issuing = {
     },
     config: {
         programs: {
-            getAll: () => apiClientFactory_1.apiClientV1.getRequest('/issuing/config/programs').then(({ data }) => data),
+            getAll: () => apiClientFactory_1.apiClientV1.getRequest('/issuing/config/programs'),
         },
     },
 };

package/dist/api/kyc.d.ts

@@ -1,6 +1,6 @@
 import { API } from './types';
 export declare const kyc: {
     sumsub: {
-        generate_token: (data: API.KYC.Sumsub.GenerateToken.Request) => Promise<import("axios").AxiosResponse<API.KYC.Sumsub.GenerateToken.Response, any>>;
+        generate_token: (data: API.KYC.Sumsub.GenerateToken.Request) => Promise<API.KYC.Sumsub.GenerateToken.Response>;
     };
 };

package/dist/api/list.js

@@ -5,9 +5,9 @@ exports.list = void 0;
 const apiClientFactory_1 = require("../utils/apiClientFactory");
 exports.list = {
     currencies: {
-        getAll: (params) => apiClientFactory_1.apiClientV2.getRequest('/currencies', params).then(({ data }) => data),
+        getAll: (params) => apiClientFactory_1.apiClientV2.getRequest('/currencies', params),
     },
     chains: {
-        getAll: (params) => apiClientFactory_1.apiClientV2.getRequest('/chains', params).then(({ data }) => data),
+        getAll: (params) => apiClientFactory_1.apiClientV2.getRequest('/chains', params),
     },
 };

package/dist/api/orders.d.ts

@@ -3,10 +3,10 @@ export declare const orders: {
     calc: ({ signal, ...params }: API.Orders.Calc.Request) => Promise<API.Orders.Calc.Response>;
     create: {
         byOrderType: {
-            TRANSFER_CARD_SUBACCOUNT: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Request) => Promise<import("axios").AxiosResponse<API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Response, any>>;
-            WITHDRAWAL_CRYPTO: (data: API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Request) => Promise<import("axios").AxiosResponse<API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Response, any>>;
-            EXCHANGE_CRYPTO_INTERNAL: (data: API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Request) => Promise<import("axios").AxiosResponse<API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Response, any>>;
-            TRANSFER_CARD_WHOLESALE: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Request) => Promise<import("axios").AxiosResponse<null, any>>;
+            TRANSFER_CARD_SUBACCOUNT: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Request) => Promise<API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Response>;
+            WITHDRAWAL_CRYPTO: (data: API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Request) => Promise<API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Response>;
+            EXCHANGE_CRYPTO_INTERNAL: (data: API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Request) => Promise<API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Response>;
+            TRANSFER_CARD_WHOLESALE: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Request) => Promise<null>;
         };
     };
 };

package/dist/api/orders.js

@@ -17,7 +17,7 @@ const constants_1 = require("../constants");
 exports.orders = {
     calc: (_a) => {
         var { signal } = _a, params = __rest(_a, ["signal"]);
-        return apiClientFactory_1.apiClientV1.getRequest('/orders/calc', { params, signal }).then((res) => res.data);
+        return apiClientFactory_1.apiClientV1.getRequest('/orders/calc', { params, signal });
     },
     create: {
         byOrderType: {

package/dist/api/user.d.ts

@@ -1,18 +1,18 @@
 import { API } from './types';
 export declare const user: {
-    get: () => Promise<import("axios").AxiosResponse<API.User.User, any>>;
+    get: () => Promise<API.User.User>;
     userData: {
-        get: () => Promise<import("axios").AxiosResponse<API.User.UserData.UserData, any>>;
-        update: (data: API.User.UserData.UpdateUserData.Request) => Promise<import("axios").AxiosResponse<API.User.UserData.UserData, any>>;
+        get: () => Promise<API.User.UserData.UserData>;
+        update: (data: API.User.UserData.UpdateUserData.Request) => Promise<API.User.UserData.UserData>;
     };
     update: {
         phone: {
-            request: (data: API.User.UpdateUser.Phone.RequestOTP.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
-            confirm: (data: API.User.UpdateUser.Phone.Confirm.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
+            request: (data: API.User.UpdateUser.Phone.RequestOTP.Request) => Promise<unknown>;
+            confirm: (data: API.User.UpdateUser.Phone.Confirm.Request) => Promise<unknown>;
         };
         email: {
-            request: (data: API.User.UpdateUser.Email.RequestOTP.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
-            confirm: (data: API.User.UpdateUser.Email.Confirm.Request) => Promise<import("axios").AxiosResponse<unknown, any>>;
+            request: (data: API.User.UpdateUser.Email.RequestOTP.Request) => Promise<unknown>;
+            confirm: (data: API.User.UpdateUser.Email.Confirm.Request) => Promise<unknown>;
         };
     };
 };

package/dist/api/wallets.js

@@ -13,30 +13,24 @@ exports.wallets = void 0;
 const apiClientFactory_1 = require("../utils/apiClientFactory");
 const constants_1 = require("../constants");
 exports.wallets = {
-    create: (type) => apiClientFactory_1.apiClientV2.postRequest('/wallets', { data: { type } }).then(({ data }) => data),
-    getAll: () => apiClientFactory_1.apiClientV2.getRequest('/wallets').then(({ data }) => data),
-    getByUuid: (uuid) => apiClientFactory_1.apiClientV2.getRequest(`/wallets/${uuid}`).then(({ data }) => data),
+    create: (type) => apiClientFactory_1.apiClientV2.postRequest('/wallets', { data: { type } }),
+    getAll: () => apiClientFactory_1.apiClientV2.getRequest('/wallets'),
+    getByUuid: (uuid) => apiClientFactory_1.apiClientV2.getRequest(`/wallets/${uuid}`),
     addresses: {
-        create: ({ wallet_uuid, chain, label }) => apiClientFactory_1.apiClientV2
-            .postRequest(`/wallets/${wallet_uuid}/addresses/${chain}`, {
+        create: ({ wallet_uuid, chain, label }) => apiClientFactory_1.apiClientV2.postRequest(`/wallets/${wallet_uuid}/addresses/${chain}`, {
             data: { label },
-        })
-            .then(({ data }) => data),
+        }),
         get: {
             byWalletUuid: {
-                byChainId: (wallet_uuid, chain_id) => apiClientFactory_1.apiClientV2
-                    .getRequest(`/wallets/${wallet_uuid}/addresses/${chain_id}`)
-                    .then(({ data }) => data),
+                byChainId: (wallet_uuid, chain_id) => apiClientFactory_1.apiClientV2.getRequest(`/wallets/${wallet_uuid}/addresses/${chain_id}`),
             },
         },
     },
     transactions: {
         getByWalletUuid: (wallet_uuid_1, ...args_1) => __awaiter(void 0, [wallet_uuid_1, ...args_1], void 0, function* (wallet_uuid, limit = constants_1.defaultPaginationParams.limit, offset = constants_1.defaultPaginationParams.offset) {
-            return apiClientFactory_1.apiClientV2
-                .getRequest(`/wallets/${wallet_uuid}/transactions`, {
+            return apiClientFactory_1.apiClientV2.getRequest(`/wallets/${wallet_uuid}/transactions`, {
                 params: { limit, offset },
-            })
-                .then(({ data }) => data);
+            });
         }),
     },
 };

package/dist/utils/apiClientFactory.d.ts

@@ -1,25 +1,25 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AxiosRequestConfig } from 'axios';
 type CreateApiClientOptions = {
     baseURL: string;
     tenantId: string;
     isBearerToken?: boolean;
 };
 export declare const createApiClient: ({ baseURL, isBearerToken, tenantId }: CreateApiClientOptions) => {
-    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
-    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
-    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<any, any>>;
-    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
 };
 export declare const apiClientV1: {
-    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
-    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
-    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<any, any>>;
-    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
 };
 export declare const apiClientV2: {
-    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
-    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
-    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<any, any>>;
-    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
 };
 export {};

package/dist/utils/apiClientFactory.js

@@ -115,22 +115,22 @@ const createApiClient = ({ baseURL, isBearerToken, tenantId }) => {
     const patchRequest = (url, config) => __awaiter(void 0, void 0, void 0, function* () {
         const _a = config !== null && config !== void 0 ? config : {}, { data = {} } = _a, restConfig = __rest(_a, ["data"]);
         const res = yield instance.patch(url, data, restConfig);
-        return res;
+        return res.data;
     });
     const postRequest = (url, config) => __awaiter(void 0, void 0, void 0, function* () {
         const _a = config !== null && config !== void 0 ? config : {}, { data = {} } = _a, restConfig = __rest(_a, ["data"]);
         const res = yield instance.post(url, data, restConfig);
-        return res;
+        return res.data;
     });
     const deleteRequest = (url, config) => __awaiter(void 0, void 0, void 0, function* () {
         const _a = config !== null && config !== void 0 ? config : {}, { data = {} } = _a, restConfig = __rest(_a, ["data"]);
         const res = yield instance.delete(url, Object.assign({ data }, restConfig));
-        return res;
+        return res.data;
     });
     const getRequest = (url, config) => __awaiter(void 0, void 0, void 0, function* () {
         const _a = config !== null && config !== void 0 ? config : {}, { params = {} } = _a, restConfig = __rest(_a, ["params"]);
         const res = yield instance.get(url, Object.assign({ params }, restConfig));
-        return res;
+        return res.data;
     });
     return { patchRequest, postRequest, deleteRequest, getRequest };
 };

package/dist/utils/tokensFactory.js

@@ -40,9 +40,9 @@ function refreshTokens() {
                 })
                 : auth_1.auth.refresh.refresh_token(refreshToken);
         };
-        const { data } = yield refreshHandler();
-        setTokens(data);
-        return data;
+        const tokens = yield refreshHandler();
+        setTokens(tokens);
+        return tokens;
     });
 }
 function getTokens() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squarefi-bff-api-module",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Squarefi BFF API client module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api/exchange.ts

@@ -6,17 +6,11 @@ import { OrderType } from '../constants';
 
 const createOrderTypeMethods = (orderType: OrderType) => ({
   getByFromCurrency: (from_uuid: string) =>
-    apiClientV1
-      .getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { from_uuid, order_type: orderType } })
-      .then(({ data }) => data),
+    apiClientV1.getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { from_uuid, order_type: orderType } }),
   getByToCurrency: (to_uuid: string) =>
-    apiClientV1
-      .getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { to_uuid, order_type: orderType } })
-      .then(({ data }) => data),
+    apiClientV1.getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { to_uuid, order_type: orderType } }),
   getByOrderType: () =>
-    apiClientV1
-      .getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { order_type: orderType } })
-      .then(({ data }) => data),
+    apiClientV1.getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { order_type: orderType } }),
 });
 
 export const exchange = {

package/src/api/issuing.ts

@@ -1,5 +1,3 @@
-import { AxiosResponse } from 'axios';
-
 import { fiat_accounts } from './fiat_accounts';
 import { API } from './types';
 
@@ -19,17 +17,15 @@ export const issuing = {
       apiClientV1.getRequest<API.Cards.CardsList.Response>('/issuing/cards', { params }),
     getByFiatAccountAndWalletId: (params: API.Cards.CardsList.Request.ByFiatAccountAndWalletId) =>
       apiClientV1.getRequest<API.Cards.CardsList.Response>('/issuing/cards', { params }),
-    getById: async (card_id: string): Promise<AxiosResponse<API.Cards.CardDetailItem, any>> => {
-      const { data: card, ...rest } = await apiClientV1.getRequest<API.Cards.CardDetailItem>(
-        `/issuing/cards/${card_id}`
-      );
-      const { data: fiatAccountData } = await fiat_accounts.getByUuid(card.fiat_account.id);
+    getById: async (card_id: string): Promise<API.Cards.CardDetailItem> => {
+      const card = await apiClientV1.getRequest<API.Cards.CardDetailItem>(`/issuing/cards/${card_id}`);
+      const fiatAccountData = await fiat_accounts.getByUuid(card.fiat_account.id);
 
       // const { data: fiatAccountData } = await fiat_accounts.getByUuid({ V2 API FIAT ACCOUNTS
       //   wallet_uuid: card.fiat_account.wallet_id,
       //   fiat_account_id: card.fiat_account.id,
       // });
-      return { ...rest, data: { ...card, fiat_account: { ...fiatAccountData, type: card.fiat_account.type } } };
+      return { ...card, fiat_account: { ...fiatAccountData, type: card.fiat_account.type } };
     },
     sensitiveData: {
       get: (card_id: string) => apiClientV1.getRequest<API.Cards.SensitiveData>(`/issuing/cards/${card_id}/sensitive`),
@@ -59,8 +55,7 @@ export const issuing = {
   },
   config: {
     programs: {
-      getAll: () =>
-        apiClientV1.getRequest<API.Issuing.Programs.Response>('/issuing/config/programs').then(({ data }) => data),
+      getAll: () => apiClientV1.getRequest<API.Issuing.Programs.Response>('/issuing/config/programs'),
     },
   },
 };

package/src/api/list.ts

@@ -8,11 +8,9 @@ import { apiClientV2 } from '../utils/apiClientFactory';
 
 export const list = {
   currencies: {
-    getAll: (params?: AxiosRequestConfig) =>
-      apiClientV2.getRequest<API.Currencies.CurrencyList>('/currencies', params).then(({ data }) => data),
+    getAll: (params?: AxiosRequestConfig) => apiClientV2.getRequest<API.Currencies.CurrencyList>('/currencies', params),
   },
   chains: {
-    getAll: (params?: AxiosRequestConfig) =>
-      apiClientV2.getRequest<API.Chains.ChainList>('/chains', params).then(({ data }) => data),
+    getAll: (params?: AxiosRequestConfig) => apiClientV2.getRequest<API.Chains.ChainList>('/chains', params),
   },
 };

package/src/api/orders.ts

@@ -6,7 +6,7 @@ import { OrderType } from '../constants';
 
 export const orders = {
   calc: ({ signal, ...params }: API.Orders.Calc.Request) =>
-    apiClientV1.getRequest<API.Orders.Calc.Response>('/orders/calc', { params, signal }).then((res) => res.data),
+    apiClientV1.getRequest<API.Orders.Calc.Response>('/orders/calc', { params, signal }),
   create: {
     byOrderType: {
       [OrderType.TRANSFER_CARD_SUBACCOUNT]: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Request) =>

package/src/api/wallets.ts

@@ -5,22 +5,18 @@ import { apiClientV2 } from '../utils/apiClientFactory';
 import { defaultPaginationParams, WalletTypeValues } from '../constants';
 
 export const wallets = {
-  create: (type: WalletTypeValues) => apiClientV2.postRequest('/wallets', { data: { type } }).then(({ data }) => data),
-  getAll: () => apiClientV2.getRequest<API.Wallets.WalletsList.Response>('/wallets').then(({ data }) => data),
-  getByUuid: (uuid: string) => apiClientV2.getRequest<API.Wallets.Wallet>(`/wallets/${uuid}`).then(({ data }) => data),
+  create: (type: WalletTypeValues) => apiClientV2.postRequest('/wallets', { data: { type } }),
+  getAll: () => apiClientV2.getRequest<API.Wallets.WalletsList.Response>('/wallets'),
+  getByUuid: (uuid: string) => apiClientV2.getRequest<API.Wallets.Wallet>(`/wallets/${uuid}`),
   addresses: {
     create: ({ wallet_uuid, chain, label }: API.Wallets.WalletChain.Create.Request) =>
-      apiClientV2
-        .postRequest<API.Wallets.WalletChain.Create.Response>(`/wallets/${wallet_uuid}/addresses/${chain}`, {
-          data: { label },
-        })
-        .then(({ data }) => data),
+      apiClientV2.postRequest<API.Wallets.WalletChain.Create.Response>(`/wallets/${wallet_uuid}/addresses/${chain}`, {
+        data: { label },
+      }),
     get: {
       byWalletUuid: {
         byChainId: (wallet_uuid: string, chain_id: number) =>
-          apiClientV2
-            .getRequest<API.Wallets.WalletChain.WalletChain>(`/wallets/${wallet_uuid}/addresses/${chain_id}`)
-            .then(({ data }) => data),
+          apiClientV2.getRequest<API.Wallets.WalletChain.WalletChain>(`/wallets/${wallet_uuid}/addresses/${chain_id}`),
       },
     },
   },
@@ -30,10 +26,11 @@ export const wallets = {
       limit = defaultPaginationParams.limit,
       offset = defaultPaginationParams.offset
     ) =>
-      apiClientV2
-        .getRequest<API.Wallets.WalletTransactions.TransactionList.Response>(`/wallets/${wallet_uuid}/transactions`, {
+      apiClientV2.getRequest<API.Wallets.WalletTransactions.TransactionList.Response>(
+        `/wallets/${wallet_uuid}/transactions`,
+        {
           params: { limit, offset },
-        })
-        .then(({ data }) => data),
+        }
+      ),
   },
 };

package/src/utils/apiClientFactory.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 import { isTMA } from '@telegram-apps/sdk-react';
-import axios, { AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import axios, { AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios';
 
 import { telegramSignUpPath, telegramSignInPath, refreshTokenPath } from '../api/auth';
 
@@ -122,20 +122,20 @@ export const createApiClient = ({ baseURL, isBearerToken, tenantId }: CreateApiC
     }
   );
 
-  const patchRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> => {
+  const patchRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
     const { data = {}, ...restConfig } = config ?? {};
 
     const res = await instance.patch(url, data, restConfig);
 
-    return res;
+    return res.data;
   };
 
-  const postRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> => {
+  const postRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
     const { data = {}, ...restConfig } = config ?? {};
 
     const res = await instance.post(url, data, restConfig);
 
-    return res;
+    return res.data;
   };
 
   const deleteRequest = async (url: string, config?: AxiosRequestConfig) => {
@@ -143,15 +143,15 @@ export const createApiClient = ({ baseURL, isBearerToken, tenantId }: CreateApiC
 
     const res = await instance.delete(url, { data, ...restConfig });
 
-    return res;
+    return res.data;
   };
 
-  const getRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> => {
+  const getRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
     const { params = {}, ...restConfig } = config ?? {};
 
     const res = await instance.get(url, { params, ...restConfig });
 
-    return res;
+    return res.data;
   };
 
   return { patchRequest, postRequest, deleteRequest, getRequest };

package/src/utils/tokensFactory.ts

@@ -35,11 +35,11 @@ export async function refreshTokens() {
         })
       : auth.refresh.refresh_token(refreshToken as string);
 
-  const { data } = await refreshHandler();
+  const tokens = await refreshHandler();
 
-  setTokens(data);
+  setTokens(tokens);
 
-  return data;
+  return tokens;
 }
 
 export function getTokens() {