squarefi-bff-api-module 1.0.0

package/dist/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/user.d.ts

@@ -0,0 +1,18 @@
+import { API } from './types';
+export declare const user: {
+    get: () => Promise<import("axios").AxiosResponse<API.User.User, any>>;
+    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>>;
+    };
+    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>>;
+        };
+        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>>;
+        };
+    };
+};

package/dist/api/user.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.user = void 0;
+const _1 = require(".");
+exports.user = {
+    get: () => _1.apiClientV2.getRequest('/user'),
+    userData: {
+        get: () => _1.apiClientV2.getRequest('/user/user-data'),
+        update: (data) => _1.apiClientV2.patchRequest('/user/user-data', { data }),
+    },
+    update: {
+        phone: {
+            request: (data) => _1.apiClientV2.patchRequest('/user/phone', { data }),
+            confirm: (data) => _1.apiClientV2.postRequest('/user/phone', { data }),
+        },
+        email: {
+            request: (data) => _1.apiClientV2.patchRequest('/user/email', { data }),
+            confirm: (data) => _1.apiClientV2.postRequest('/user/email', { data }),
+        },
+    },
+};

package/dist/api/wallets.d.ts

@@ -0,0 +1,18 @@
+import { API } from './types';
+import { WalletTypeValues } from '../constants';
+export declare const wallets: {
+    create: (type: WalletTypeValues) => Promise<unknown>;
+    getAll: () => Promise<API.Wallets.WalletsList.Response>;
+    getByUuid: (uuid: string) => Promise<API.Wallets.Wallet>;
+    addresses: {
+        create: ({ wallet_uuid, chain, label }: API.Wallets.WalletChain.Create.Request) => Promise<API.Wallets.WalletChain.WalletChain>;
+        get: {
+            byWalletUuid: {
+                byChainId: (wallet_uuid: string, chain_id: number) => Promise<API.Wallets.WalletChain.WalletChain>;
+            };
+        };
+    };
+    transactions: {
+        getByWalletUuid: (wallet_uuid: string, limit?: number, offset?: number) => Promise<API.Wallets.WalletTransactions.TransactionList.Response>;
+    };
+};

package/dist/api/wallets.js

@@ -0,0 +1,42 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wallets = void 0;
+const _1 = require(".");
+const constants_1 = require("../constants");
+exports.wallets = {
+    create: (type) => _1.apiClientV2.postRequest('/wallets', { data: { type } }).then(({ data }) => data),
+    getAll: () => _1.apiClientV2.getRequest('/wallets').then(({ data }) => data),
+    getByUuid: (uuid) => _1.apiClientV2.getRequest(`/wallets/${uuid}`).then(({ data }) => data),
+    addresses: {
+        create: ({ wallet_uuid, chain, label }) => _1.apiClientV2
+            .postRequest(`/wallets/${wallet_uuid}/addresses/${chain}`, {
+            data: { label },
+        })
+            .then(({ data }) => data),
+        get: {
+            byWalletUuid: {
+                byChainId: (wallet_uuid, chain_id) => _1.apiClientV2
+                    .getRequest(`/wallets/${wallet_uuid}/addresses/${chain_id}`)
+                    .then(({ data }) => data),
+            },
+        },
+    },
+    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 _1.apiClientV2
+                .getRequest(`/wallets/${wallet_uuid}/transactions`, {
+                params: { limit, offset },
+            })
+                .then(({ data }) => data);
+        }),
+    },
+};

package/dist/constants.d.ts

@@ -0,0 +1,149 @@
+export type ValueWithLabel = {
+    value: string;
+    label: string;
+};
+export type WalletType = {
+    [key: string]: ValueWithLabel;
+};
+export declare const falsyValues: (string | number | boolean | null | undefined)[];
+export declare enum AppEnviroment {
+    WEB = "web",
+    TELEGRAM = "telegram"
+}
+export declare enum CardFormFactor {
+    VIRTUAL = "VIRTUAL",
+    PHYSICAL = "PHYSICAL"
+}
+export declare enum CardType {
+    CREDIT = "CREDIT",
+    DEBIT = "DEBIT"
+}
+export declare enum CardTransactionType {
+    AUTHORIZATION = "AUTHORIZATION",
+    CLEARING = "CLEARING",
+    REFUND = "REFUND",
+    REVERSAL = "REVERSAL",
+    ORIGINAL_CREDIT = "ORIGINAL_CREDIT",
+    FEE = "FEE",
+    DEPOSIT = "DEPOSIT",
+    WITHDRAWAL = "WITHDRAWAL"
+}
+export declare enum WalletTransactionType {
+    DEPOSIT = "deposit",
+    WITHDRAWAL = "withdrawal"
+}
+export declare enum WalletTransactionMethod {
+    P2P = "p2p",
+    CRYPTO = "crypto",
+    BANK_TRANSFER = "bank_transfer",
+    EXCHANGE = "exchange",
+    SBP = "sbp"
+}
+export declare enum WalletTransactionRecordType {
+    CARD_PROVIDER_DEPOSIT = "CARD_PROVIDER_DEPOSIT",
+    CARD_PROVIDER_REFUND = "CARD_PROVIDER_REFUND",
+    DEPOSIT = "DEPOSIT",
+    DEPOSIT_CRYPTO_EXTERNAL = "DEPOSIT_CRYPTO_EXTERNAL",
+    DEPOSIT_CRYPTO_INTERNAL = "DEPOSIT_CRYPTO_INTERNAL",
+    EXCHANGE_CRYPTO_INTERNAL = "EXCHANGE_CRYPTO_INTERNAL",
+    EXT_EXCHANGE = "EXT_EXCHANGE",
+    FEE = "FEE",
+    NETWORK_FEE = "NETWORK_FEE",
+    REFUND = "REFUND",
+    WITHDRAWAL = "WITHDRAWAL",
+    WITHDRAWAL_CRYPTO_EXTERNAL = "WITHDRAWAL_CRYPTO_EXTERNAL",
+    WITHDRAWAL_CRYPTO_INTERNAL = "WITHDRAWAL_CRYPTO_INTERNAL",
+    WHOLESALE_CARD_DEPOSIT = "WHOLESALE_CARD_DEPOSIT"
+}
+export declare enum RequestStatus {
+    NONE = "none",
+    PENDING = "pending",
+    FULLFILLED = "fulfilled",
+    REJECTED = "rejected"
+}
+export declare enum RequestLoadingType {
+    NORMAL = "normal",
+    TRANSPARENT = "transparent"
+}
+export declare enum ResponseStatus {
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    VERIFICATION_EXPIRED = 419,
+    UNPROCESSABLE_ENTITY = 422,
+    USER_BLOCKED = 423,
+    SERVER_ERROR = 500
+}
+export declare enum WalletTypeValues {
+    BUSINESS = "business",
+    PERSONAL = "personal",
+    P2P = "trading",
+    ESCROW = "escrow",
+    MERCHANT = "merchant",
+    EXCHANGE = "exchange",
+    STAKING = "staking",
+    VAULT = "vault"
+}
+export declare const walletType: WalletType;
+export declare const defaultPaginationParams: {
+    limit: number;
+    offset: number;
+    isLastPage: boolean;
+};
+export declare enum KYCStatuses {
+    APPROVED = "APPROVED",
+    DECLINED = "DECLINED",
+    PENDING = "PENDING",
+    HOLD = "HOLD",
+    DOUBLE = "DOUBLE",
+    SOFT_REJECT = "SOFT_REJECT",
+    REJECT = "REJECT",
+    UNVERIFIED = "UNVERIFIED"
+}
+export declare enum OrderStatuses {
+    NEW = "NEW",
+    PENDING = "PENDING",
+    CANCELED = "CANCELED",
+    COMPLETE = "COMPLETE",
+    ERROR = "ERROR",
+    FAILED = "FAILED"
+}
+export declare enum CardStatus {
+    ACTIVE = "ACTIVE",
+    FROZEN = "FROZEN",
+    BLOCKED = "BLOCKED",
+    INACTIVE = "INACTIVE",
+    CANCELED = "CANCELED",
+    CLOSED = "CLOSED"
+}
+export declare enum FiatAccountStatus {
+    ACTIVE = "ACTIVE",
+    BLOCKED = "BLOCKED",
+    INACTIVE = "INACTIVE",
+    CANCELED = "CANCELED"
+}
+export declare enum SubAccountType {
+    PREPAID = "prepaid",
+    BALANCE = "balance"
+}
+export declare enum CurrencyType {
+    TOKEN = "token",
+    NATIVE = "native",
+    FIAT = "fiat"
+}
+export declare enum OrderType {
+    DEPOSIT_FIAT_SEPA = "DEPOSIT_FIAT_SEPA",
+    DEPOSIT_FIAT_SWIFT = "DEPOSIT_FIAT_SWIFT",
+    WITHDRAWAL_FIAT_SEPA = "WITHDRAWAL_FIAT_SEPA",
+    TRANSFER_CARD_PREPAID = "TRANSFER_CARD_PREPAID",
+    TRANSFER_CARD_SUBACCOUNT = "TRANSFER_CARD_SUBACCOUNT",
+    WITHDRAWAL_CRYPTO = "WITHDRAWAL_CRYPTO",
+    EXCHANGE_CRYPTO_INTERNAL = "EXCHANGE_CRYPTO_INTERNAL",
+    TRANSFER_CARD_WHOLESALE = "TRANSFER_CARD_WHOLESALE"
+}
+export declare enum APIKeyRole {
+    READ_ONLY = "READ_ONLY",
+    DEVELOPER = "DEVELOPER",
+    PRODUCTION = "PRODUCTION"
+}

package/dist/constants.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIKeyRole = exports.OrderType = exports.CurrencyType = exports.SubAccountType = exports.FiatAccountStatus = exports.CardStatus = exports.OrderStatuses = exports.KYCStatuses = exports.defaultPaginationParams = exports.walletType = exports.WalletTypeValues = exports.ResponseStatus = exports.RequestLoadingType = exports.RequestStatus = exports.WalletTransactionRecordType = exports.WalletTransactionMethod = exports.WalletTransactionType = exports.CardTransactionType = exports.CardType = exports.CardFormFactor = exports.AppEnviroment = exports.falsyValues = void 0;
+exports.falsyValues = ['false', '0', '', 'FALSE', false, null, undefined, NaN, 0];
+var AppEnviroment;
+(function (AppEnviroment) {
+    AppEnviroment["WEB"] = "web";
+    AppEnviroment["TELEGRAM"] = "telegram";
+})(AppEnviroment || (exports.AppEnviroment = AppEnviroment = {}));
+var CardFormFactor;
+(function (CardFormFactor) {
+    CardFormFactor["VIRTUAL"] = "VIRTUAL";
+    CardFormFactor["PHYSICAL"] = "PHYSICAL";
+})(CardFormFactor || (exports.CardFormFactor = CardFormFactor = {}));
+var CardType;
+(function (CardType) {
+    CardType["CREDIT"] = "CREDIT";
+    CardType["DEBIT"] = "DEBIT";
+})(CardType || (exports.CardType = CardType = {}));
+var CardTransactionType;
+(function (CardTransactionType) {
+    CardTransactionType["AUTHORIZATION"] = "AUTHORIZATION";
+    CardTransactionType["CLEARING"] = "CLEARING";
+    CardTransactionType["REFUND"] = "REFUND";
+    CardTransactionType["REVERSAL"] = "REVERSAL";
+    CardTransactionType["ORIGINAL_CREDIT"] = "ORIGINAL_CREDIT";
+    CardTransactionType["FEE"] = "FEE";
+    CardTransactionType["DEPOSIT"] = "DEPOSIT";
+    CardTransactionType["WITHDRAWAL"] = "WITHDRAWAL";
+})(CardTransactionType || (exports.CardTransactionType = CardTransactionType = {}));
+var WalletTransactionType;
+(function (WalletTransactionType) {
+    WalletTransactionType["DEPOSIT"] = "deposit";
+    WalletTransactionType["WITHDRAWAL"] = "withdrawal";
+})(WalletTransactionType || (exports.WalletTransactionType = WalletTransactionType = {}));
+var WalletTransactionMethod;
+(function (WalletTransactionMethod) {
+    WalletTransactionMethod["P2P"] = "p2p";
+    WalletTransactionMethod["CRYPTO"] = "crypto";
+    WalletTransactionMethod["BANK_TRANSFER"] = "bank_transfer";
+    WalletTransactionMethod["EXCHANGE"] = "exchange";
+    WalletTransactionMethod["SBP"] = "sbp";
+})(WalletTransactionMethod || (exports.WalletTransactionMethod = WalletTransactionMethod = {}));
+var WalletTransactionRecordType;
+(function (WalletTransactionRecordType) {
+    WalletTransactionRecordType["CARD_PROVIDER_DEPOSIT"] = "CARD_PROVIDER_DEPOSIT";
+    WalletTransactionRecordType["CARD_PROVIDER_REFUND"] = "CARD_PROVIDER_REFUND";
+    WalletTransactionRecordType["DEPOSIT"] = "DEPOSIT";
+    WalletTransactionRecordType["DEPOSIT_CRYPTO_EXTERNAL"] = "DEPOSIT_CRYPTO_EXTERNAL";
+    WalletTransactionRecordType["DEPOSIT_CRYPTO_INTERNAL"] = "DEPOSIT_CRYPTO_INTERNAL";
+    WalletTransactionRecordType["EXCHANGE_CRYPTO_INTERNAL"] = "EXCHANGE_CRYPTO_INTERNAL";
+    WalletTransactionRecordType["EXT_EXCHANGE"] = "EXT_EXCHANGE";
+    WalletTransactionRecordType["FEE"] = "FEE";
+    WalletTransactionRecordType["NETWORK_FEE"] = "NETWORK_FEE";
+    WalletTransactionRecordType["REFUND"] = "REFUND";
+    WalletTransactionRecordType["WITHDRAWAL"] = "WITHDRAWAL";
+    WalletTransactionRecordType["WITHDRAWAL_CRYPTO_EXTERNAL"] = "WITHDRAWAL_CRYPTO_EXTERNAL";
+    WalletTransactionRecordType["WITHDRAWAL_CRYPTO_INTERNAL"] = "WITHDRAWAL_CRYPTO_INTERNAL";
+    WalletTransactionRecordType["WHOLESALE_CARD_DEPOSIT"] = "WHOLESALE_CARD_DEPOSIT";
+})(WalletTransactionRecordType || (exports.WalletTransactionRecordType = WalletTransactionRecordType = {}));
+var RequestStatus;
+(function (RequestStatus) {
+    RequestStatus["NONE"] = "none";
+    RequestStatus["PENDING"] = "pending";
+    RequestStatus["FULLFILLED"] = "fulfilled";
+    RequestStatus["REJECTED"] = "rejected";
+})(RequestStatus || (exports.RequestStatus = RequestStatus = {}));
+var RequestLoadingType;
+(function (RequestLoadingType) {
+    RequestLoadingType["NORMAL"] = "normal";
+    RequestLoadingType["TRANSPARENT"] = "transparent";
+})(RequestLoadingType || (exports.RequestLoadingType = RequestLoadingType = {}));
+var ResponseStatus;
+(function (ResponseStatus) {
+    ResponseStatus[ResponseStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    ResponseStatus[ResponseStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    ResponseStatus[ResponseStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    ResponseStatus[ResponseStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    ResponseStatus[ResponseStatus["VERIFICATION_EXPIRED"] = 419] = "VERIFICATION_EXPIRED";
+    ResponseStatus[ResponseStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    ResponseStatus[ResponseStatus["USER_BLOCKED"] = 423] = "USER_BLOCKED";
+    ResponseStatus[ResponseStatus["SERVER_ERROR"] = 500] = "SERVER_ERROR";
+})(ResponseStatus || (exports.ResponseStatus = ResponseStatus = {}));
+var WalletTypeValues;
+(function (WalletTypeValues) {
+    WalletTypeValues["BUSINESS"] = "business";
+    WalletTypeValues["PERSONAL"] = "personal";
+    WalletTypeValues["P2P"] = "trading";
+    WalletTypeValues["ESCROW"] = "escrow";
+    WalletTypeValues["MERCHANT"] = "merchant";
+    WalletTypeValues["EXCHANGE"] = "exchange";
+    WalletTypeValues["STAKING"] = "staking";
+    WalletTypeValues["VAULT"] = "vault";
+})(WalletTypeValues || (exports.WalletTypeValues = WalletTypeValues = {}));
+exports.walletType = {
+    personal: { value: WalletTypeValues.PERSONAL, label: 'Personal' },
+    p2p: { value: 'p2p', label: 'P2P' },
+    escrow: { value: WalletTypeValues.ESCROW, label: 'Escrow' },
+    merchant: { value: WalletTypeValues.MERCHANT, label: 'Merchant' },
+    exchange: { value: WalletTypeValues.EXCHANGE, label: 'Exchange' },
+    staking: { value: WalletTypeValues.STAKING, label: 'Staking' },
+    vault: { value: WalletTypeValues.VAULT, label: 'Vault' },
+};
+exports.defaultPaginationParams = {
+    limit: 10,
+    offset: 0,
+    isLastPage: true,
+};
+var KYCStatuses;
+(function (KYCStatuses) {
+    KYCStatuses["APPROVED"] = "APPROVED";
+    KYCStatuses["DECLINED"] = "DECLINED";
+    KYCStatuses["PENDING"] = "PENDING";
+    KYCStatuses["HOLD"] = "HOLD";
+    KYCStatuses["DOUBLE"] = "DOUBLE";
+    KYCStatuses["SOFT_REJECT"] = "SOFT_REJECT";
+    KYCStatuses["REJECT"] = "REJECT";
+    KYCStatuses["UNVERIFIED"] = "UNVERIFIED";
+})(KYCStatuses || (exports.KYCStatuses = KYCStatuses = {}));
+var OrderStatuses;
+(function (OrderStatuses) {
+    OrderStatuses["NEW"] = "NEW";
+    OrderStatuses["PENDING"] = "PENDING";
+    OrderStatuses["CANCELED"] = "CANCELED";
+    OrderStatuses["COMPLETE"] = "COMPLETE";
+    OrderStatuses["ERROR"] = "ERROR";
+    OrderStatuses["FAILED"] = "FAILED";
+})(OrderStatuses || (exports.OrderStatuses = OrderStatuses = {}));
+var CardStatus;
+(function (CardStatus) {
+    CardStatus["ACTIVE"] = "ACTIVE";
+    CardStatus["FROZEN"] = "FROZEN";
+    CardStatus["BLOCKED"] = "BLOCKED";
+    CardStatus["INACTIVE"] = "INACTIVE";
+    CardStatus["CANCELED"] = "CANCELED";
+    CardStatus["CLOSED"] = "CLOSED";
+})(CardStatus || (exports.CardStatus = CardStatus = {}));
+var FiatAccountStatus;
+(function (FiatAccountStatus) {
+    FiatAccountStatus["ACTIVE"] = "ACTIVE";
+    FiatAccountStatus["BLOCKED"] = "BLOCKED";
+    FiatAccountStatus["INACTIVE"] = "INACTIVE";
+    FiatAccountStatus["CANCELED"] = "CANCELED";
+})(FiatAccountStatus || (exports.FiatAccountStatus = FiatAccountStatus = {}));
+var SubAccountType;
+(function (SubAccountType) {
+    SubAccountType["PREPAID"] = "prepaid";
+    SubAccountType["BALANCE"] = "balance";
+})(SubAccountType || (exports.SubAccountType = SubAccountType = {}));
+var CurrencyType;
+(function (CurrencyType) {
+    CurrencyType["TOKEN"] = "token";
+    CurrencyType["NATIVE"] = "native";
+    CurrencyType["FIAT"] = "fiat";
+})(CurrencyType || (exports.CurrencyType = CurrencyType = {}));
+var OrderType;
+(function (OrderType) {
+    OrderType["DEPOSIT_FIAT_SEPA"] = "DEPOSIT_FIAT_SEPA";
+    OrderType["DEPOSIT_FIAT_SWIFT"] = "DEPOSIT_FIAT_SWIFT";
+    OrderType["WITHDRAWAL_FIAT_SEPA"] = "WITHDRAWAL_FIAT_SEPA";
+    OrderType["TRANSFER_CARD_PREPAID"] = "TRANSFER_CARD_PREPAID";
+    OrderType["TRANSFER_CARD_SUBACCOUNT"] = "TRANSFER_CARD_SUBACCOUNT";
+    OrderType["WITHDRAWAL_CRYPTO"] = "WITHDRAWAL_CRYPTO";
+    OrderType["EXCHANGE_CRYPTO_INTERNAL"] = "EXCHANGE_CRYPTO_INTERNAL";
+    OrderType["TRANSFER_CARD_WHOLESALE"] = "TRANSFER_CARD_WHOLESALE";
+})(OrderType || (exports.OrderType = OrderType = {}));
+var APIKeyRole;
+(function (APIKeyRole) {
+    APIKeyRole["READ_ONLY"] = "READ_ONLY";
+    APIKeyRole["DEVELOPER"] = "DEVELOPER";
+    APIKeyRole["PRODUCTION"] = "PRODUCTION";
+})(APIKeyRole || (exports.APIKeyRole = APIKeyRole = {}));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './utils/apiClientFactory';
+export * from './utils/tokensFactory';
+export * from './constants';
+export * from './api/types';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./utils/apiClientFactory"), exports);
+__exportStar(require("./utils/tokensFactory"), exports);
+__exportStar(require("./constants"), exports);
+// Also export types if you have any
+__exportStar(require("./api/types"), exports);

package/dist/utils/apiClientFactory.d.ts

@@ -0,0 +1,13 @@
+import { AxiosRequestConfig, AxiosResponse } 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>>;
+};
+export {};

package/dist/utils/apiClientFactory.js

@@ -0,0 +1,132 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiClient = void 0;
+/* eslint-disable no-console */
+const sdk_react_1 = require("@telegram-apps/sdk-react");
+const axios_1 = __importDefault(require("axios"));
+const auth_1 = require("../api/auth");
+const constants_1 = require("../constants");
+const storage_1 = require("../utils/storage");
+const tokensFactory_1 = require("../utils/tokensFactory");
+const createApiClient = ({ baseURL, isBearerToken, tenantId }) => {
+    const instance = axios_1.default.create({
+        baseURL,
+        timeout: 60000,
+    });
+    instance.interceptors.request.use((config) => {
+        const access_token = (0, storage_1.getFromLocalStorage)('access_token');
+        const modifiedHeaders = Object.assign(Object.assign({}, config.headers), { 'App-Enviroment': (0, sdk_react_1.isTMA)() ? constants_1.AppEnviroment.TELEGRAM : constants_1.AppEnviroment.WEB, 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'x-tenant-id': tenantId });
+        if (access_token) {
+            const authHeader = isBearerToken ? `Bearer ${access_token}` : access_token;
+            modifiedHeaders.Authorization = authHeader;
+        }
+        return Object.assign(Object.assign({}, config), { headers: modifiedHeaders });
+    });
+    let isTokenRefreshing = false;
+    let requestQueue = [];
+    instance.interceptors.response.use((response) => response, (error) => {
+        var _a, _b, _c, _d;
+        if (typeof window === 'undefined') {
+            return Promise.reject(error);
+        }
+        if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) === constants_1.ResponseStatus.UNAUTHORIZED) {
+            const { response, config: failedRequest } = error;
+            const refreshToken = (0, storage_1.getFromLocalStorage)('refresh_token');
+            const isRetryRequest = failedRequest.headers['X-Retry-Request'];
+            const isRefreshTokenRequest = (_b = response === null || response === void 0 ? void 0 : response.config) === null || _b === void 0 ? void 0 : _b.url.includes(auth_1.refreshTokenPath);
+            const isTelegramSignInRequest = (_c = response === null || response === void 0 ? void 0 : response.config) === null || _c === void 0 ? void 0 : _c.url.includes(auth_1.telegramSignInPath);
+            const isTelegramSignUpRequest = (_d = response === null || response === void 0 ? void 0 : response.config) === null || _d === void 0 ? void 0 : _d.url.includes(auth_1.telegramSignUpPath);
+            const isRefreshNotRequired = !refreshToken && !(0, sdk_react_1.isTMA)();
+            const isLogoutNeccesary = isRefreshNotRequired ||
+                isTelegramSignInRequest ||
+                isTelegramSignUpRequest ||
+                isRefreshTokenRequest ||
+                isRetryRequest;
+            const isRefreshAvailable = (!isTokenRefreshing && typeof refreshToken === 'string') || (0, sdk_react_1.isTMA)();
+            if (isLogoutNeccesary) {
+                if (typeof window !== 'undefined') {
+                    // navigate('/auth/logout');
+                    (0, tokensFactory_1.deleteTokens)();
+                }
+                requestQueue = [];
+                return Promise.reject(response);
+            }
+            if (isRefreshAvailable) {
+                (0, tokensFactory_1.refreshTokens)()
+                    .then((data) => {
+                    if (data === null || data === void 0 ? void 0 : data.access_token) {
+                        requestQueue.forEach((request) => request.resolve());
+                        requestQueue = [];
+                    }
+                })
+                    .catch((tokenRefreshError) => {
+                    if (typeof window !== 'undefined') {
+                        // navigate('/auth/logout');
+                        (0, tokensFactory_1.deleteTokens)();
+                    }
+                    requestQueue = [];
+                    return Promise.reject(tokenRefreshError);
+                })
+                    .finally(() => {
+                    isTokenRefreshing = false;
+                });
+            }
+            return new Promise((res, rej) => {
+                requestQueue.push({
+                    resolve: () => {
+                        failedRequest.headers['X-Retry-Request'] = 'true';
+                        return res(instance(failedRequest));
+                    },
+                    reject: () => rej(instance(failedRequest)),
+                });
+            });
+        }
+        console.error('Axios error', error);
+        return Promise.reject(error);
+    });
+    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;
+    });
+    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;
+    });
+    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;
+    });
+    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 { patchRequest, postRequest, deleteRequest, getRequest };
+};
+exports.createApiClient = createApiClient;

package/dist/utils/storage.d.ts

@@ -0,0 +1,3 @@
+export declare const getFromLocalStorage: (key: string) => string | null;
+export declare const setToLocalStorage: (key: string, value: string) => void;
+export declare const deleteFromLocalStorage: (key: string) => void;

package/dist/utils/storage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFromLocalStorage = exports.setToLocalStorage = exports.getFromLocalStorage = void 0;
+const getFromLocalStorage = (key) => {
+    if (typeof window === 'undefined') {
+        // eslint-disable-next-line no-console
+        console.error('call getFromLocalStorage in server side');
+        return null;
+    }
+    return localStorage.getItem(key);
+};
+exports.getFromLocalStorage = getFromLocalStorage;
+const setToLocalStorage = (key, value) => {
+    if (typeof window === 'undefined') {
+        // eslint-disable-next-line no-console
+        console.error('call setToLocalStorage in server side');
+        return;
+    }
+    localStorage.setItem(key, value);
+};
+exports.setToLocalStorage = setToLocalStorage;
+const deleteFromLocalStorage = (key) => {
+    if (typeof window === 'undefined') {
+        // eslint-disable-next-line no-console
+        console.error('call deleteFromLocalStorage in server side');
+        return;
+    }
+    localStorage.removeItem(key);
+};
+exports.deleteFromLocalStorage = deleteFromLocalStorage;

package/dist/utils/tokensFactory.d.ts

@@ -0,0 +1,12 @@
+type SetTokensProps = {
+    access_token: string;
+    refresh_token?: string;
+};
+export declare function setTokens({ access_token, refresh_token }: SetTokensProps): void;
+export declare function deleteTokens(): void;
+export declare function refreshTokens(): Promise<import("..").API.Auth.Tokens | null>;
+export declare function getTokens(): {
+    access_token: string | null;
+    refresh_token: string | null;
+};
+export {};