squarefi-bff-api-module 1.0.0

package/README.md

@@ -0,0 +1,36 @@
+# Squarefi BFF API Module
+
+A TypeScript/JavaScript client for interacting with the Squarefi BFF API.
+
+## Installation
+
+```bash
+npm install squarefi-bff-api-module
+```
+
+## Usage
+
+```typescript
+import { createApiClient } from 'squarefi-bff-api-module';
+
+const api = createApiClient({
+  baseURL: 'YOUR_API_BASE_URL',
+  tenantId: 'YOUR_TENANT_ID',
+  isBearerToken: true,
+});
+
+// Make API calls
+const response = await api.getRequest('/some-endpoint');
+```
+
+## Features
+
+- Full TypeScript support
+- Axios-based HTTP client
+- Token management
+- Telegram integration support
+- Comprehensive constants and types
+
+## License
+
+MIT

package/dist/api/auth.d.ts

@@ -0,0 +1,27 @@
+import { API } from './types';
+export declare const telegramSignInPath = "/auth/sign-in/telegram";
+export declare const telegramSignUpPath = "/auth/sign-up/telegram";
+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>>;
+        };
+    };
+    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>>;
+        };
+        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>>;
+    };
+    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>>;
+    };
+    refresh: {
+        refresh_token: (refresh_token: string) => Promise<import("axios").AxiosResponse<API.Auth.Tokens, any>>;
+    };
+};

package/dist/api/auth.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auth = exports.refreshTokenPath = exports.telegramSignUpPath = exports.telegramSignInPath = void 0;
+const _1 = require(".");
+exports.telegramSignInPath = '/auth/sign-in/telegram';
+exports.telegramSignUpPath = '/auth/sign-up/telegram';
+exports.refreshTokenPath = '/auth/refresh/refresh-token';
+exports.auth = {
+    otp: {
+        verify: {
+            email: (email, token) => _1.apiClientV2.postRequest('/auth/verify/email/otp', {
+                data: { email, token, type: 'email' },
+            }),
+            phone: (phone, token) => _1.apiClientV2.postRequest('/auth/verify/phone/otp', {
+                data: { phone, token, type: 'sms' },
+            }),
+        },
+    },
+    signin: {
+        omni: {
+            email: (data) => _1.apiClientV2.postRequest('/auth/sign-in/omni/email/otp', { data }),
+            phone: (data) => _1.apiClientV2.postRequest('/auth/sign-in/omni/phone/otp', { data }),
+        },
+        telegram: (data) => _1.apiClientV2.postRequest(exports.telegramSignInPath, { data }),
+        password: (email, password) => _1.apiClientV2.postRequest('/auth/sign-in/password', {
+            data: { email, password },
+        }),
+    },
+    signup: {
+        password: (email, password) => _1.apiClientV2.postRequest('/auth/sign-up/password', {
+            data: { email, password },
+        }),
+        telegram: (data) => _1.apiClientV2.postRequest(exports.telegramSignUpPath, { data }),
+    },
+    refresh: {
+        refresh_token: (refresh_token) => _1.apiClientV2.postRequest(exports.refreshTokenPath, { data: { refresh_token } }),
+    },
+};

package/dist/api/config.d.ts

@@ -0,0 +1,37 @@
+export declare const baseURL: string;
+export declare const tenantId: string | undefined;
+export declare const pathnames: {
+    readonly auth: {
+        readonly me: "/auth/me";
+        readonly otp: {
+            readonly request: {
+                readonly email: "/auth/signin/email/otp";
+                readonly phone: "/auth/signin/phone/otp";
+            };
+            readonly verify: {
+                readonly email: "/auth/verify/email/otp";
+                readonly phone: "/auth/verify/phone/otp";
+            };
+        };
+        readonly signin: {
+            readonly password: {
+                readonly email: "/auth/signin/password/email";
+                readonly phone: "/auth/signin/password/phone";
+            };
+        };
+        readonly signup: {
+            readonly email: "/auth/signup/email";
+            readonly password: {
+                readonly email: "/auth/signup/password/email";
+                readonly phone: "/auth/signup/password/phone";
+            };
+        };
+        readonly refresh: {
+            readonly refresh_token: "/auth/refresh/refresh_token";
+        };
+        readonly user_data: {
+            readonly get: "/auth/user_data";
+            readonly update: "/auth/user_data";
+        };
+    };
+};

package/dist/api/config.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathnames = exports.tenantId = exports.baseURL = void 0;
+exports.baseURL = process.env.API_URL || '/api/';
+exports.tenantId = process.env.TENANT_ID;
+exports.pathnames = {
+    auth: {
+        me: '/auth/me',
+        otp: {
+            request: {
+                email: '/auth/signin/email/otp',
+                phone: '/auth/signin/phone/otp',
+            },
+            verify: {
+                email: '/auth/verify/email/otp',
+                phone: '/auth/verify/phone/otp',
+            },
+        },
+        signin: {
+            password: {
+                email: '/auth/signin/password/email',
+                phone: '/auth/signin/password/phone',
+            },
+        },
+        signup: {
+            email: '/auth/signup/email',
+            password: {
+                email: '/auth/signup/password/email',
+                phone: '/auth/signup/password/phone',
+            },
+        },
+        refresh: {
+            refresh_token: '/auth/refresh/refresh_token',
+        },
+        user_data: {
+            get: '/auth/user_data',
+            update: '/auth/user_data',
+        },
+    },
+};

package/dist/api/developer.d.ts

@@ -0,0 +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>>;
+    };
+    vendors: {
+        list: () => Promise<import("axios").AxiosResponse<API.Developer.Vendors.Vendor[], any>>;
+    };
+};

package/dist/api/developer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.developer = void 0;
+const _1 = require(".");
+exports.developer = {
+    apiKeys: {
+        getAll: () => _1.apiClientV1.getRequest('/developer/access/list'),
+        create: (data) => _1.apiClientV1.postRequest('/developer/access/create', { data }),
+        rotate: (data) => _1.apiClientV1.postRequest(`/developer/access/rotate`, { data }),
+        update: (data) => _1.apiClientV1.postRequest(`/developer/access/update`, { data }),
+    },
+    vendors: {
+        list: () => _1.apiClientV1.getRequest('/developer/vendors/list'),
+    },
+};

package/dist/api/exchange.d.ts

@@ -0,0 +1,35 @@
+import { API } from './types';
+export declare const exchange: {
+    byOrderType: {
+        DEPOSIT_FIAT_SEPA: {
+            getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+        };
+        DEPOSIT_FIAT_SWIFT: {
+            getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+        };
+        WITHDRAWAL_FIAT_SEPA: {
+            getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+        };
+        TRANSFER_CARD_SUBACCOUNT: {
+            getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+        };
+        WITHDRAWAL_CRYPTO: {
+            getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+        };
+        EXCHANGE_CRYPTO_INTERNAL: {
+            getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+            getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+        };
+    };
+};

package/dist/api/exchange.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exchange = void 0;
+const _1 = require(".");
+const constants_1 = require("../constants");
+const createOrderTypeMethods = (orderType) => ({
+    getByFromCurrency: (from_uuid) => _1.apiClientV1
+        .getRequest('/exchange/', { params: { from_uuid, order_type: orderType } })
+        .then(({ data }) => data),
+    getByToCurrency: (to_uuid) => _1.apiClientV1
+        .getRequest('/exchange/', { params: { to_uuid, order_type: orderType } })
+        .then(({ data }) => data),
+    getByOrderType: () => _1.apiClientV1
+        .getRequest('/exchange/', { params: { order_type: orderType } })
+        .then(({ data }) => data),
+});
+exports.exchange = {
+    byOrderType: {
+        [constants_1.OrderType.DEPOSIT_FIAT_SEPA]: createOrderTypeMethods(constants_1.OrderType.DEPOSIT_FIAT_SEPA),
+        [constants_1.OrderType.DEPOSIT_FIAT_SWIFT]: createOrderTypeMethods(constants_1.OrderType.DEPOSIT_FIAT_SWIFT),
+        [constants_1.OrderType.WITHDRAWAL_FIAT_SEPA]: createOrderTypeMethods(constants_1.OrderType.WITHDRAWAL_FIAT_SEPA),
+        // [OrderType.TRANSFER_CARD_PREPAID]: createOrderTypeMethods(OrderType.TRANSFER_CARD_PREPAID), // DO not used
+        [constants_1.OrderType.TRANSFER_CARD_SUBACCOUNT]: createOrderTypeMethods(constants_1.OrderType.TRANSFER_CARD_SUBACCOUNT),
+        [constants_1.OrderType.WITHDRAWAL_CRYPTO]: createOrderTypeMethods(constants_1.OrderType.WITHDRAWAL_CRYPTO),
+        [constants_1.OrderType.EXCHANGE_CRYPTO_INTERNAL]: createOrderTypeMethods(constants_1.OrderType.EXCHANGE_CRYPTO_INTERNAL),
+    },
+};

package/dist/api/fetch_api.d.ts

@@ -0,0 +1 @@
+export declare const test = 123;

package/dist/api/fetch_api.js

@@ -0,0 +1,122 @@
+"use strict";
+// // import { toast } from 'react-toastify';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+// import { auth } from './auth';
+// import { baseURL, pathnames, tenantId } from './config';
+// import { RequestConfig, RequestMethods, RequestOptions, RequestQueueItem } from './types';
+// import { getAuthCookie } from '@/actions/auth.action';
+// import { handleLogout } from '@/actions/redirect.action';
+// import { ResponseStatus } from '@/constants';
+// import { deleteTokens, refreshTokens, setTokens } from '@/helpers/serverTokensFactory';
+// const logLevel = 'debug';
+// let isTokenRefreshing = false;
+// let requestQueue: RequestQueueItem[] = [];
+// const createRequestHandler = (method: RequestMethods) => {
+//   const requestHandler = async <T>(url: string, requestConfig?: RequestConfig): Promise<T> => {
+//     const { headers, data } = requestConfig || {};
+//     const { access_token, refresh_token } = await getAuthCookie();
+//     const options: RequestOptions = {
+//       method,
+//       headers: {
+//         'Content-Type': 'application/json',
+//         'X-Tenant-Id': tenantId,
+//         ...headers,
+//       },
+//       body: data ? JSON.stringify(data) : undefined,
+//     };
+//     if (access_token) {
+//       options.headers = {
+//         ...options.headers,
+//         Authorization: access_token,
+//       };
+//     }
+//     const urlSearchParams = new URLSearchParams(requestConfig?.params);
+//     const requestUrl = new URL(`${baseURL}${url}?${urlSearchParams}`);
+//     if (logLevel === 'debug') {
+//       const requestLog = `[fetch][request] ${requestUrl}`;
+//       // eslint-disable-next-line no-console
+//       console.debug(requestLog);
+//     }
+//     const response = await fetch(requestUrl, options);
+//     const isError = !response.ok;
+//     const { status: responseStatus } = response;
+//     const currentTime = new Date().getMilliseconds();
+//     const requestSendTime = new Date(response.headers.get('date') || currentTime).getMilliseconds();
+//     const requestTime = (currentTime - requestSendTime) / 1000;
+//     const responseLog = `[fetch][${
+//       isError ? 'error' : 'response'
+//     }] ${method} ${responseStatus} ${requestUrl} +${requestTime}s`;
+//     if (logLevel === 'debug') {
+//       // eslint-disable-next-line no-console
+//       console.debug(responseLog);
+//     }
+//     if (isError) {
+//       if (response?.status === ResponseStatus.UNAUTHORIZED && access_token && typeof window !== 'undefined') {
+//         const isRefreshTokenRequest = url === pathnames.auth.refresh.refresh_token;
+//         const isRefreshAvailable = !isTokenRefreshing && refresh_token;
+//         const isLogoutNeccesary = !isRefreshAvailable || isRefreshTokenRequest;
+//         if (isLogoutNeccesary) {
+//           await deleteTokens();
+//           requestQueue.forEach((request) => request.reject());
+//           requestQueue = [];
+//           handleLogout();
+//           return Promise.reject(response);
+//         }
+//         if (isRefreshAvailable) {
+//           refreshTokens(refresh_token).then((tokens) => {
+//             setTokens(tokens); // todo set clients/server cookies
+//             requestQueue.forEach((request) => request.resolve());
+//             requestQueue = [];
+//             isTokenRefreshing = false;
+//           });
+//         }
+//         return new Promise((res, rej) => {
+//           requestQueue.push({
+//             resolve: () => res(requestHandler(url, requestConfig)),
+//             reject: () => rej(requestHandler(url, requestConfig)),
+//           });
+//         });
+//       }
+//       try {
+//         const errorData = await response.text();
+//         let parsedError;
+//         try {
+//           parsedError = JSON.parse(errorData);
+//         } catch {
+//           // Extract error message from HTML if it contains <!DOCTYPE html>
+//           if (errorData.includes('<!DOCTYPE html>')) {
+//             const messageMatch = errorData.match(/<pre>([^<]+)<\/pre>/);
+//             const extractedMessage = messageMatch ? messageMatch[1] : null;
+//             parsedError = {
+//               status: response.status,
+//               message: extractedMessage || response.statusText || 'Unknown error occurred',
+//             };
+//           } else {
+//             // If not HTML, use raw text as message
+//             parsedError = {
+//               status: response.status,
+//               message: errorData || response.statusText || 'Unknown error occurred',
+//             };
+//           }
+//         }
+//         return Promise.reject(parsedError);
+//       } catch (error) {
+//         // If we can't even read the response text, return a basic error
+//         const basicError = new Error('Failed to read error response');
+//         basicError.cause = response.status;
+//         basicError.message = response.statusText || 'Failed to read error response';
+//         return Promise.reject(basicError);
+//       }
+//     }
+//     const responseData = await response.json();
+//     return responseData;
+//   };
+//   return requestHandler;
+// };
+// export const getRequest = createRequestHandler('GET');
+// export const deleteRequest = createRequestHandler('DELETE');
+// export const patchRequest = createRequestHandler('PATCH');
+// export const postRequest = createRequestHandler('POST');
+// export { auth };
+exports.test = 123;

package/dist/api/fiat_accounts.d.ts

@@ -0,0 +1,32 @@
+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>>;
+        };
+        withoutCards: {
+            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.FiatAccountsListWithoutCards, any>>;
+        };
+    };
+    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>>;
+    transactions: {
+        get: ({ fiat_account_id, wallet_uuid, limit, offset }: API.FiatAccountsV2.Transactions.TransactionList.Request) => Promise<import("axios").AxiosResponse<API.FiatAccountsV2.Transactions.TransactionList.Response, any>>;
+    };
+};
+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>>;
+        };
+        withoutCards: {
+            getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<import("axios").AxiosResponse<API.FiatAccounts.FiatAccount[], any>>;
+        };
+    };
+    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>>;
+    transactions: {
+        get: (fiat_account_id: string, limit?: number, offset?: number) => Promise<import("axios").AxiosResponse<API.FiatAccounts.TransactionList, any>>;
+    };
+};

package/dist/api/fiat_accounts.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fiat_accounts = exports.fiat_accounts_v2 = void 0;
+const _1 = require(".");
+exports.fiat_accounts_v2 = {
+    list: {
+        withCards: {
+            getAll: (wallet_uuid, limit, offset) => _1.apiClientV2.getRequest(`/fiat-accounts/${wallet_uuid}`, {
+                params: { limit, offset, show_cards: true },
+            }),
+        },
+        withoutCards: {
+            getAll: (wallet_uuid, limit, offset) => _1.apiClientV2.getRequest(`/fiat-accounts/${wallet_uuid}`, {
+                params: { limit, offset },
+            }),
+        },
+    },
+    getByUuid: ({ wallet_uuid, fiat_account_id }) => _1.apiClientV2.getRequest(`/fiat-accounts/${wallet_uuid}/${fiat_account_id}`),
+    create: ({ wallet_id, program_id }) => _1.apiClientV2.postRequest(`/fiat-accounts/${wallet_id}`, {
+        data: { program_id },
+    }),
+    transactions: {
+        get: ({ fiat_account_id, wallet_uuid, limit, offset }) => _1.apiClientV2.getRequest(`/fiat-accounts/${wallet_uuid}/${fiat_account_id}/transactions`, {
+            params: { limit, offset },
+        }),
+    },
+};
+exports.fiat_accounts = {
+    list: {
+        withCards: {
+            getSinglecards: (wallet_uuid, limit, offset) => _1.apiClientV1.getRequest(`/fiat_accounts/list/${wallet_uuid}`, {
+                params: { limit, offset, lt_cards_limit: 2, gt_cards_limit: 0, show_cards: true },
+            }),
+            getAll: (wallet_uuid, limit, offset) => _1.apiClientV1.getRequest(`/fiat_accounts/list/${wallet_uuid}`, {
+                params: { limit, offset, show_cards: true },
+            }),
+        },
+        withoutCards: {
+            getAll: (wallet_uuid, limit, offset) => _1.apiClientV1.getRequest(`/fiat_accounts/list/${wallet_uuid}`, {
+                params: { limit, offset },
+            }),
+        },
+    },
+    getByUuid: (uuid) => _1.apiClientV1.getRequest(`/fiat_accounts/${uuid}`),
+    create: (wallet_id, program_id) => _1.apiClientV1.postRequest(`/fiat_accounts`, { data: { wallet_id, program_id } }),
+    transactions: {
+        get: (fiat_account_id, limit, offset) => _1.apiClientV1.getRequest(`/fiat_accounts/${fiat_account_id}/transactions`, {
+            params: { limit, offset },
+        }),
+    },
+};

package/dist/api/index.d.ts

@@ -0,0 +1,12 @@
+export declare const apiClientV1: {
+    patchRequest: <T>(url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T>>;
+    postRequest: <T>(url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T>>;
+    deleteRequest: (url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    getRequest: <T>(url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T>>;
+};
+export declare const apiClientV2: {
+    patchRequest: <T>(url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T>>;
+    postRequest: <T>(url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T>>;
+    deleteRequest: (url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    getRequest: <T>(url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T>>;
+};

package/dist/api/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiClientV2 = exports.apiClientV1 = void 0;
+const apiClientFactory_1 = require("../utils/apiClientFactory");
+const apiV1BaseURL = (_a = process.env.API_URL) !== null && _a !== void 0 ? _a : 'ENV variable API_URL is not defined';
+const apiV2BaseURL = (_b = process.env.API_V2_URL) !== null && _b !== void 0 ? _b : 'ENV variable API_V2_URL is not defined';
+const envTenantId = (_c = process.env.TENANT_ID) !== null && _c !== void 0 ? _c : 'ENV variable TENANT_ID is not defined';
+exports.apiClientV1 = (0, apiClientFactory_1.createApiClient)({
+    baseURL: apiV1BaseURL,
+    tenantId: envTenantId,
+});
+exports.apiClientV2 = (0, apiClientFactory_1.createApiClient)({
+    baseURL: apiV2BaseURL,
+    isBearerToken: true,
+    tenantId: envTenantId,
+});

package/dist/api/issuing.d.ts

@@ -0,0 +1,31 @@
+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>>;
+        };
+        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>>;
+        sensitiveData: {
+            get: (card_id: string) => Promise<AxiosResponse<API.Cards.SensitiveData, any>>;
+            otp: {
+                get: (card_id: string) => Promise<AxiosResponse<API.Cards.OTP, any>>;
+            };
+        };
+        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>>;
+    };
+    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>>;
+    };
+    config: {
+        programs: {
+            getAll: () => Promise<API.Issuing.Programs.Response>;
+        };
+    };
+};

package/dist/api/issuing.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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");
+const _1 = require(".");
+const constants_1 = require("../constants");
+exports.issuing = {
+    cards: {
+        create: {
+            standAloneCard: (data) => _1.apiClientV1.postRequest('/issuing/cards/create', { data }),
+            fiatAccountCard: (data) => _1.apiClientV1.postRequest('/issuing/cards/balance', { data }),
+        },
+        getByWalletUuid: (params) => _1.apiClientV1.getRequest('/issuing/cards', { params }),
+        getByFiatAccountAndWalletId: (params) => _1.apiClientV1.getRequest('/issuing/cards', { params }),
+        getById: (card_id) => __awaiter(void 0, void 0, void 0, function* () {
+            const _a = yield _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 { 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 }) }) });
+        }),
+        sensitiveData: {
+            get: (card_id) => _1.apiClientV1.getRequest(`/issuing/cards/${card_id}/sensitive`),
+            otp: {
+                // have to update
+                get: (card_id) => _1.apiClientV1.getRequest(`/vcards/cards/${card_id}/sensitive/otp`),
+            },
+        },
+        close: (card_id) => _1.apiClientV1.deleteRequest(`/issuing/cards/${card_id}`),
+        freeze: (card_id) => _1.apiClientV1.patchRequest(`/issuing/cards/${card_id}/freeze`),
+        unfreeze: (card_id) => _1.apiClientV1.patchRequest(`/issuing/cards/${card_id}/unfreeze`),
+    },
+    transactions: {
+        getByCardId: (card_id, limit = constants_1.defaultPaginationParams.limit, offset = constants_1.defaultPaginationParams.offset) => _1.apiClientV1.getRequest(`/issuing/transactions/`, {
+            params: { limit, offset, card_id, new_scheme: true },
+        }),
+        getByFiatAccountId: (fiat_account_id, limit = constants_1.defaultPaginationParams.limit, offset = constants_1.defaultPaginationParams.offset) => _1.apiClientV1.getRequest(`/issuing/transactions/`, {
+            params: { limit, offset, fiat_account_id, new_scheme: true },
+        }),
+    },
+    config: {
+        programs: {
+            getAll: () => _1.apiClientV1.getRequest('/issuing/config/programs').then(({ data }) => data),
+        },
+    },
+};

package/dist/api/kyc.d.ts

@@ -0,0 +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>>;
+    };
+};

package/dist/api/kyc.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kyc = void 0;
+const _1 = require(".");
+exports.kyc = {
+    sumsub: {
+        generate_token: (data) => _1.apiClientV1.postRequest('/kyc/sumsub/generate_token', { data }),
+    },
+};

package/dist/api/list.d.ts

@@ -0,0 +1,10 @@
+import { AxiosRequestConfig } from 'axios';
+import { API } from './types';
+export declare const list: {
+    currencies: {
+        getAll: (params?: AxiosRequestConfig) => Promise<API.Currencies.CurrencyList>;
+    };
+    chains: {
+        getAll: (params?: AxiosRequestConfig) => Promise<API.Chains.ChainList>;
+    };
+};