squarefi-bff-api-module 1.32.1 → 1.32.2

package/dist/constants.js

@@ -0,0 +1,332 @@
+export const falsyValues = ['false', '0', '', 'FALSE', false, null, undefined, NaN, 0];
+export var AppEnviroment;
+(function (AppEnviroment) {
+    AppEnviroment["WEB"] = "web";
+    AppEnviroment["TELEGRAM"] = "telegram";
+})(AppEnviroment || (AppEnviroment = {}));
+export var CardFormFactor;
+(function (CardFormFactor) {
+    CardFormFactor["VIRTUAL"] = "VIRTUAL";
+    CardFormFactor["PHYSICAL"] = "PHYSICAL";
+})(CardFormFactor || (CardFormFactor = {}));
+export var CardType;
+(function (CardType) {
+    CardType["CREDIT"] = "CREDIT";
+    CardType["DEBIT"] = "DEBIT";
+})(CardType || (CardType = {}));
+export 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["PAYMENT"] = "PAYMENT";
+    CardTransactionType["PURCHASE"] = "PURCHASE";
+})(CardTransactionType || (CardTransactionType = {}));
+export var WalletTransactionType;
+(function (WalletTransactionType) {
+    WalletTransactionType["DEPOSIT"] = "deposit";
+    WalletTransactionType["WITHDRAWAL"] = "withdrawal";
+})(WalletTransactionType || (WalletTransactionType = {}));
+export var WalletTransactionMethod;
+(function (WalletTransactionMethod) {
+    WalletTransactionMethod["P2P"] = "p2p";
+    WalletTransactionMethod["CRYPTO"] = "crypto";
+    WalletTransactionMethod["BANK_TRANSFER"] = "bank_transfer";
+    WalletTransactionMethod["EXCHANGE"] = "exchange";
+    WalletTransactionMethod["SBP"] = "sbp";
+})(WalletTransactionMethod || (WalletTransactionMethod = {}));
+export var WalletTransactionStatus;
+(function (WalletTransactionStatus) {
+    WalletTransactionStatus["COMPLETE"] = "complete";
+    WalletTransactionStatus["PENDING"] = "pending";
+    WalletTransactionStatus["CANCELED"] = "canceled";
+    WalletTransactionStatus["FAILED"] = "failed";
+    WalletTransactionStatus["PROCESSING"] = "processing";
+    WalletTransactionStatus["NEW"] = "new";
+})(WalletTransactionStatus || (WalletTransactionStatus = {}));
+export var OrderPaymentMethod;
+(function (OrderPaymentMethod) {
+    OrderPaymentMethod["ACH"] = "ACH";
+    OrderPaymentMethod["SEPA"] = "SEPA";
+    OrderPaymentMethod["SWIFT"] = "SWIFT";
+    OrderPaymentMethod["DOMESTIC_WIRE"] = "DOMESTIC_WIRE";
+    OrderPaymentMethod["CRYPTO_EXTERNAL"] = "CRYPTO_EXTERNAL";
+    OrderPaymentMethod["CRYPTO_INTERNAL"] = "CRYPTO_INTERNAL";
+    OrderPaymentMethod["CHAPS"] = "CHAPS";
+    OrderPaymentMethod["FPS"] = "FPS";
+})(OrderPaymentMethod || (OrderPaymentMethod = {}));
+export var OrderType;
+(function (OrderType) {
+    // when extend do not forget to add new order type to the enum WalletTransactionRecordType
+    OrderType["DEPOSIT_ISSUING_SA_CRYPTO_EXT"] = "DEPOSIT_ISSUING_SA_CRYPTO_EXT";
+    OrderType["DEPOSIT_ISSUING_SA_SEPA_EXT"] = "DEPOSIT_ISSUING_SA_SEPA_EXT";
+    OrderType["DEPOSIT_CRYPTO"] = "DEPOSIT_CRYPTO";
+    OrderType["DEPOSIT_FIAT_SEPA"] = "DEPOSIT_FIAT_SEPA";
+    OrderType["DEPOSIT_FIAT_SWIFT"] = "DEPOSIT_FIAT_SWIFT";
+    OrderType["EXCHANGE_CRYPTO_INTERNAL"] = "EXCHANGE_CRYPTO_INTERNAL";
+    OrderType["EXCHANGE_OMNI"] = "EXCHANGE_OMNI";
+    OrderType["TRANSFER_CARD_PREPAID"] = "TRANSFER_CARD_PREPAID";
+    OrderType["CARD_ISSUING_FEE"] = "CARD_ISSUING_FEE";
+    OrderType["TRANSFER_CARD_SUBACCOUNT"] = "TRANSFER_CARD_SUBACCOUNT";
+    OrderType["TRANSFER_CARD_WHOLESALE"] = "TRANSFER_CARD_WHOLESALE";
+    OrderType["TRANSFER_INTERNAL"] = "TRANSFER_INTERNAL";
+    OrderType["WITHDRAWAL_CRYPTO"] = "WITHDRAWAL_CRYPTO";
+    OrderType["WITHDRAWAL_FIAT_SEPA"] = "WITHDRAWAL_FIAT_SEPA";
+    OrderType["HIFI_WIRE_ONRAMP"] = "HIFI_WIRE_ONRAMP";
+    OrderType["HIFI_WIRE_OFFRAMP"] = "HIFI_WIRE_OFFRAMP";
+    OrderType["HIFI_WIRE_DEPOSIT"] = "HIFI_WIRE_DEPOSIT";
+    OrderType["HIFI_WIRE_WITHDRAWAL"] = "HIFI_WIRE_WITHDRAWAL";
+    OrderType["HIFI_ACH_ONRAMP"] = "HIFI_ACH_ONRAMP";
+    OrderType["HIFI_ACH_OFFRAMP"] = "HIFI_ACH_OFFRAMP";
+    OrderType["HIFI_ACH_DEPOSIT"] = "HIFI_ACH_DEPOSIT";
+    OrderType["HIFI_ACH_WITHDRAWAL"] = "HIFI_ACH_WITHDRAWAL";
+    OrderType["HIFI_SEPA_ONRAMP"] = "HIFI_SEPA_ONRAMP";
+    OrderType["HIFI_SEPA_OFFRAMP"] = "HIFI_SEPA_OFFRAMP";
+    OrderType["HIFI_SEPA_DEPOSIT"] = "HIFI_SEPA_DEPOSIT";
+    OrderType["HIFI_SEPA_WITHDRAWAL"] = "HIFI_SEPA_WITHDRAWAL";
+    OrderType["HIFI_CRYPTO_TRANSFER"] = "HIFI_CRYPTO_TRANSFER";
+    OrderType["HIFI_CRYPTO_WITHDRAWAL"] = "HIFI_CRYPTO_WITHDRAWAL";
+    OrderType["HIFI_CRYPTO_DEPOSIT"] = "HIFI_CRYPTO_DEPOSIT";
+    OrderType["OMNIBUS_CRYPTO_TRANSFER"] = "OMNIBUS_CRYPTO_TRANSFER";
+    OrderType["RN_CARDS_OFFRAMP"] = "RN_CARDS_OFFRAMP";
+    OrderType["TBD_SWIFT_WITHDRAWAL"] = "TBD_SWIFT_WITHDRAWAL";
+    OrderType["SEGREGATED_CRYPTO_TRANSFER"] = "SEGREGATED_CRYPTO_TRANSFER";
+    OrderType["L2F_ACH_ONRAMP"] = "L2F_ACH_ONRAMP";
+    OrderType["L2F_ACH_OFFRAMP"] = "L2F_ACH_OFFRAMP";
+    OrderType["L2F_ACH_DEPOSIT"] = "L2F_ACH_DEPOSIT";
+    OrderType["L2F_ACH_WITHDRAWAL"] = "L2F_ACH_WITHDRAWAL";
+    OrderType["L2F_WIRE_ONRAMP"] = "L2F_WIRE_ONRAMP";
+    OrderType["L2F_WIRE_OFFRAMP"] = "L2F_WIRE_OFFRAMP";
+    OrderType["L2F_WIRE_DEPOSIT"] = "L2F_WIRE_DEPOSIT";
+    OrderType["L2F_WIRE_WITHDRAWAL"] = "L2F_WIRE_WITHDRAWAL";
+    OrderType["L2F_SWIFT_ONRAMP"] = "L2F_SWIFT_ONRAMP";
+    OrderType["L2F_SWIFT_OFFRAMP"] = "L2F_SWIFT_OFFRAMP";
+    OrderType["L2F_SWIFT_DEPOSIT"] = "L2F_SWIFT_DEPOSIT";
+    OrderType["L2F_SWIFT_WITHDRAWAL"] = "L2F_SWIFT_WITHDRAWAL";
+    OrderType["L2F_SEPA_ONRAMP"] = "L2F_SEPA_ONRAMP";
+    OrderType["L2F_SEPA_OFFRAMP"] = "L2F_SEPA_OFFRAMP";
+    OrderType["L2F_SEPA_DEPOSIT"] = "L2F_SEPA_DEPOSIT";
+    OrderType["L2F_SEPA_WITHDRAWAL"] = "L2F_SEPA_WITHDRAWAL";
+    OrderType["L2F_CRYPTO_WITHDRAWAL"] = "L2F_CRYPTO_WITHDRAWAL";
+    OrderType["L2F_CRYPTO_DEPOSIT"] = "L2F_CRYPTO_DEPOSIT";
+    OrderType["OMNIBUS_CRYPTO_WITHDRAWAL"] = "OMNIBUS_CRYPTO_WITHDRAWAL";
+    OrderType["WITHDRAW_CARD_PREPAID"] = "WITHDRAW_CARD_PREPAID";
+    OrderType["WITHDRAW_CARD_SUBACCOUNT"] = "WITHDRAW_CARD_SUBACCOUNT";
+})(OrderType || (OrderType = {}));
+export 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["DEPOSIT_INTERNAL"] = "DEPOSIT_INTERNAL";
+    WalletTransactionRecordType["DEPOSIT_MANUAL"] = "DEPOSIT_MANUAL";
+    WalletTransactionRecordType["EXCHANGE_CRYPTO_INTERNAL"] = "EXCHANGE_CRYPTO_INTERNAL";
+    WalletTransactionRecordType["EXCHANGE_OMNI"] = "EXCHANGE_OMNI";
+    WalletTransactionRecordType["EXT_EXCHANGE"] = "EXT_EXCHANGE";
+    WalletTransactionRecordType["FEE"] = "FEE";
+    WalletTransactionRecordType["NETWORK_FEE"] = "NETWORK_FEE";
+    WalletTransactionRecordType["OFFRAMP_ACHWIRE"] = "OFFRAMP_ACHWIRE";
+    WalletTransactionRecordType["OFFRAMP_SEPA"] = "OFFRAMP_SEPA";
+    WalletTransactionRecordType["OMNIBUS_CRYPTO_TRANSFER"] = "OMNIBUS_CRYPTO_TRANSFER";
+    WalletTransactionRecordType["ONRAMP_ACHWIRE"] = "ONRAMP_ACHWIRE";
+    WalletTransactionRecordType["ONRAMP_SEPA"] = "ONRAMP_SEPA";
+    WalletTransactionRecordType["REFUND"] = "REFUND";
+    WalletTransactionRecordType["RN_CARDS_OFFRAMP"] = "RN_CARDS_OFFRAMP";
+    WalletTransactionRecordType["TRANSFER_CARD_PREPAID"] = "TRANSFER_CARD_PREPAID";
+    WalletTransactionRecordType["TRANSFER_CARD_SUBACCOUNT"] = "TRANSFER_CARD_SUBACCOUNT";
+    WalletTransactionRecordType["TRANSFER_CARD_WHOLESALE"] = "TRANSFER_CARD_WHOLESALE";
+    WalletTransactionRecordType["TRANSFER_INTERNAL"] = "TRANSFER_INTERNAL";
+    WalletTransactionRecordType["SEGREGATED_CRYPTO_TRANSFER"] = "SEGREGATED_CRYPTO_TRANSFER";
+    WalletTransactionRecordType["WHOLESALE_CARD_DEPOSIT"] = "WHOLESALE_CARD_DEPOSIT";
+    WalletTransactionRecordType["WITHDRAWAL"] = "WITHDRAWAL";
+    WalletTransactionRecordType["WITHDRAWAL_CRYPTO_EXTERNAL"] = "WITHDRAWAL_CRYPTO_EXTERNAL";
+    WalletTransactionRecordType["WITHDRAWAL_CRYPTO_INTERNAL"] = "WITHDRAWAL_CRYPTO_INTERNAL";
+    WalletTransactionRecordType["WITHDRAWAL_INTERNAL"] = "WITHDRAWAL_INTERNAL";
+    WalletTransactionRecordType["WITHDRAW_CARD_PREPAID"] = "WITHDRAW_CARD_PREPAID";
+    WalletTransactionRecordType["WITHDRAW_CARD_SUBACCOUNT"] = "WITHDRAW_CARD_SUBACCOUNT";
+    WalletTransactionRecordType["L2F_ACH_ONRAMP"] = "L2F_ACH_ONRAMP";
+    WalletTransactionRecordType["L2F_ACH_OFFRAMP"] = "L2F_ACH_OFFRAMP";
+    WalletTransactionRecordType["L2F_ACH_DEPOSIT"] = "L2F_ACH_DEPOSIT";
+    WalletTransactionRecordType["L2F_ACH_WITHDRAWAL"] = "L2F_ACH_WITHDRAWAL";
+    WalletTransactionRecordType["L2F_WIRE_ONRAMP"] = "L2F_WIRE_ONRAMP";
+    WalletTransactionRecordType["L2F_WIRE_OFFRAMP"] = "L2F_WIRE_OFFRAMP";
+    WalletTransactionRecordType["L2F_WIRE_DEPOSIT"] = "L2F_WIRE_DEPOSIT";
+    WalletTransactionRecordType["L2F_WIRE_WITHDRAWAL"] = "L2F_WIRE_WITHDRAWAL";
+    WalletTransactionRecordType["L2F_SWIFT_ONRAMP"] = "L2F_SWIFT_ONRAMP";
+    WalletTransactionRecordType["L2F_SWIFT_OFFRAMP"] = "L2F_SWIFT_OFFRAMP";
+    WalletTransactionRecordType["L2F_SWIFT_DEPOSIT"] = "L2F_SWIFT_DEPOSIT";
+    WalletTransactionRecordType["L2F_SWIFT_WITHDRAWAL"] = "L2F_SWIFT_WITHDRAWAL";
+    WalletTransactionRecordType["L2F_SEPA_ONRAMP"] = "L2F_SEPA_ONRAMP";
+    WalletTransactionRecordType["L2F_SEPA_OFFRAMP"] = "L2F_SEPA_OFFRAMP";
+    WalletTransactionRecordType["L2F_SEPA_DEPOSIT"] = "L2F_SEPA_DEPOSIT";
+    WalletTransactionRecordType["L2F_SEPA_WITHDRAWAL"] = "L2F_SEPA_WITHDRAWAL";
+    WalletTransactionRecordType["L2F_CRYPTO_WITHDRAWAL"] = "L2F_CRYPTO_WITHDRAWAL";
+    WalletTransactionRecordType["L2F_CRYPTO_DEPOSIT"] = "L2F_CRYPTO_DEPOSIT";
+    WalletTransactionRecordType["HIFI_WIRE_ONRAMP"] = "HIFI_WIRE_ONRAMP";
+    WalletTransactionRecordType["HIFI_WIRE_OFFRAMP"] = "HIFI_WIRE_OFFRAMP";
+    WalletTransactionRecordType["HIFI_WIRE_DEPOSIT"] = "HIFI_WIRE_DEPOSIT";
+    WalletTransactionRecordType["HIFI_WIRE_WITHDRAWAL"] = "HIFI_WIRE_WITHDRAWAL";
+    WalletTransactionRecordType["HIFI_ACH_ONRAMP"] = "HIFI_ACH_ONRAMP";
+    WalletTransactionRecordType["HIFI_ACH_OFFRAMP"] = "HIFI_ACH_OFFRAMP";
+    WalletTransactionRecordType["HIFI_ACH_DEPOSIT"] = "HIFI_ACH_DEPOSIT";
+    WalletTransactionRecordType["HIFI_ACH_WITHDRAWAL"] = "HIFI_ACH_WITHDRAWAL";
+    WalletTransactionRecordType["HIFI_SEPA_ONRAMP"] = "HIFI_SEPA_ONRAMP";
+    WalletTransactionRecordType["HIFI_SEPA_OFFRAMP"] = "HIFI_SEPA_OFFRAMP";
+    WalletTransactionRecordType["HIFI_SEPA_DEPOSIT"] = "HIFI_SEPA_DEPOSIT";
+    WalletTransactionRecordType["HIFI_SEPA_WITHDRAWAL"] = "HIFI_SEPA_WITHDRAWAL";
+    WalletTransactionRecordType["HIFI_CRYPTO_TRANSFER"] = "HIFI_CRYPTO_TRANSFER";
+    WalletTransactionRecordType["HIFI_CRYPTO_WITHDRAWAL"] = "HIFI_CRYPTO_WITHDRAWAL";
+    WalletTransactionRecordType["HIFI_CRYPTO_DEPOSIT"] = "HIFI_CRYPTO_DEPOSIT";
+})(WalletTransactionRecordType || (WalletTransactionRecordType = {}));
+export var RequestStatus;
+(function (RequestStatus) {
+    RequestStatus["NONE"] = "none";
+    RequestStatus["PENDING"] = "pending";
+    RequestStatus["FULLFILLED"] = "fulfilled";
+    RequestStatus["REJECTED"] = "rejected";
+})(RequestStatus || (RequestStatus = {}));
+export var RequestLoadingType;
+(function (RequestLoadingType) {
+    RequestLoadingType["NORMAL"] = "normal";
+    RequestLoadingType["TRANSPARENT"] = "transparent";
+})(RequestLoadingType || (RequestLoadingType = {}));
+export 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 || (ResponseStatus = {}));
+export 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 || (WalletTypeValues = {}));
+export const 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' },
+};
+export const defaultPaginationParams = {
+    limit: 10,
+    offset: 0,
+    isLastPage: true,
+};
+export var CalcType;
+(function (CalcType) {
+    CalcType["ONRAMP"] = "onramp";
+    CalcType["OFFRAMP"] = "offramp";
+    CalcType["WITHDRAWAL"] = "withdrawal";
+})(CalcType || (CalcType = {}));
+export 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 || (KYCStatuses = {}));
+export var OrderStatuses;
+(function (OrderStatuses) {
+    OrderStatuses["NEW"] = "NEW";
+    OrderStatuses["PENDING"] = "PENDING";
+    OrderStatuses["PROCESSING"] = "PROCESSING";
+    OrderStatuses["CANCELED"] = "CANCELED";
+    OrderStatuses["COMPLETE"] = "COMPLETE";
+    OrderStatuses["ERROR"] = "ERROR";
+    OrderStatuses["FAILED"] = "FAILED";
+})(OrderStatuses || (OrderStatuses = {}));
+export var CardStatus;
+(function (CardStatus) {
+    CardStatus["ACTIVE"] = "ACTIVE";
+    CardStatus["FROZEN"] = "FROZEN";
+    CardStatus["BLOCKED"] = "BLOCKED";
+    CardStatus["INACTIVE"] = "INACTIVE";
+    CardStatus["CANCELED"] = "CANCELED";
+    CardStatus["CLOSED"] = "CLOSED";
+})(CardStatus || (CardStatus = {}));
+export var IssuingProgramStatus;
+(function (IssuingProgramStatus) {
+    IssuingProgramStatus["ACTIVE"] = "ACTIVE";
+    IssuingProgramStatus["ARCHIVED"] = "ARCHIVED";
+})(IssuingProgramStatus || (IssuingProgramStatus = {}));
+export var SubAccountStatus;
+(function (SubAccountStatus) {
+    SubAccountStatus["ACTIVE"] = "ACTIVE";
+    SubAccountStatus["BLOCKED"] = "BLOCKED";
+    SubAccountStatus["INACTIVE"] = "INACTIVE";
+    SubAccountStatus["CANCELED"] = "CANCELED";
+})(SubAccountStatus || (SubAccountStatus = {}));
+export var SubAccountType;
+(function (SubAccountType) {
+    SubAccountType["PREPAID"] = "prepaid";
+    SubAccountType["BALANCE"] = "balance";
+})(SubAccountType || (SubAccountType = {}));
+export var CurrencyType;
+(function (CurrencyType) {
+    CurrencyType["TOKEN"] = "token";
+    CurrencyType["NATIVE"] = "native";
+    CurrencyType["FIAT"] = "fiat";
+})(CurrencyType || (CurrencyType = {}));
+export var APIKeyRole;
+(function (APIKeyRole) {
+    APIKeyRole["READ_ONLY"] = "READ_ONLY";
+    APIKeyRole["DEVELOPER"] = "DEVELOPER";
+    APIKeyRole["PRODUCTION"] = "PRODUCTION";
+})(APIKeyRole || (APIKeyRole = {}));
+export var SortingDirection;
+(function (SortingDirection) {
+    SortingDirection["ASC"] = "ASC";
+    SortingDirection["DESC"] = "DESC";
+})(SortingDirection || (SortingDirection = {}));
+export var CounterpartyType;
+(function (CounterpartyType) {
+    CounterpartyType["INDIVIDUAL"] = "INDIVIDUAL";
+    CounterpartyType["BUSINESS"] = "BUSINESS";
+})(CounterpartyType || (CounterpartyType = {}));
+export var CounterpartyDestinationType;
+(function (CounterpartyDestinationType) {
+    CounterpartyDestinationType["DOMESTIC_WIRE"] = "DOMESTIC_WIRE";
+    CounterpartyDestinationType["ACH"] = "ACH";
+    CounterpartyDestinationType["SWIFT"] = "SWIFT";
+    CounterpartyDestinationType["SEPA"] = "SEPA";
+    CounterpartyDestinationType["CRYPTO_EXTERNAL"] = "CRYPTO_EXTERNAL";
+    CounterpartyDestinationType["CRYPTO_INTERNAL"] = "CRYPTO_INTERNAL";
+})(CounterpartyDestinationType || (CounterpartyDestinationType = {}));
+export var CardTransactionStatus;
+(function (CardTransactionStatus) {
+    CardTransactionStatus["APPROVED"] = "APPROVED";
+    CardTransactionStatus["CLEARED"] = "CLEARED";
+    CardTransactionStatus["COMPLETED"] = "COMPLETED";
+    CardTransactionStatus["EXPIRED"] = "EXPIRED";
+    CardTransactionStatus["FAILED"] = "FAILED";
+    CardTransactionStatus["CANCELLED"] = "CANCELLED";
+    CardTransactionStatus["CANCELED"] = "CANCELED";
+    CardTransactionStatus["PENDING"] = "PENDING";
+    CardTransactionStatus["REVERSED"] = "REVERSED";
+    CardTransactionStatus["DECLINED"] = "DECLINED";
+})(CardTransactionStatus || (CardTransactionStatus = {}));

package/dist/hooks/index.js

@@ -0,0 +1,3 @@
+export * from './useCalc';
+export * from './useSupabaseSubscription';
+export * from './useFileUpload';

package/dist/hooks/useCalc.d.ts

@@ -0,0 +1,25 @@
+import { API } from '../api/types/types';
+type CalcData = API.Orders.V2.Calc.Response & {
+    is_subtract: boolean;
+    is_reverse: boolean;
+};
+export type OrderCalcHandlerProps = Omit<API.Orders.V2.Calc.Request, 'order_type'>;
+export type UseOrderCalcProps = {
+    from_currency_id: string | null | undefined;
+    to_currency_id: string | null | undefined;
+    calcHandler: (props: OrderCalcHandlerProps) => Promise<API.Orders.V2.Calc.Response>;
+    disableCalculation?: boolean;
+    to_address?: string;
+};
+export type UseOrderCalcData = {
+    calcData: CalcData | null;
+    sellingAmount: number;
+    setSellingAmount: (value: number) => void;
+    buyingAmount: number;
+    setBuyingAmount: (value: number) => void;
+    isSellingValuePending: boolean;
+    isBuyingValuePending: boolean;
+};
+export type UseOrderCalc = (props: UseOrderCalcProps) => UseOrderCalcData;
+export declare const useOrderCalc: UseOrderCalc;
+export {};

package/dist/hooks/useCalc.js

@@ -0,0 +1,115 @@
+import debounce from 'lodash.debounce';
+import { useEffect, useRef, useState } from 'react';
+export const useOrderCalc = (props) => {
+    const { from_currency_id, to_currency_id, calcHandler, disableCalculation, to_address } = props;
+    const [sellingAmount, setSellingAmount] = useState(0);
+    const [buyingAmount, setBuyingAmount] = useState(0);
+    const [calcData, setCalcData] = useState(null);
+    const [isSellingValuePending, setIsSellingValuePending] = useState(false);
+    const [isBuyingValuePending, setIsBuyingValuePending] = useState(false);
+    const abortControllerRef = useRef(null);
+    const resetOrderCalc = () => {
+        setCalcData(null);
+        setIsSellingValuePending(false);
+        setIsBuyingValuePending(false);
+        setSellingAmount(0);
+        setBuyingAmount(0);
+    };
+    const abortCurrentCalculation = () => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+    };
+    const updateCalculations = async ({ is_reverse, is_subtract }) => {
+        if (disableCalculation) {
+            return;
+        }
+        abortControllerRef.current = new AbortController();
+        if (!from_currency_id || !to_currency_id) {
+            throw new Error('From currency or to currency is not defined');
+        }
+        if (sellingAmount === 0 && buyingAmount === 0 && !calcData) {
+            resetOrderCalc();
+            return;
+        }
+        const calcParams = {
+            from_currency_id,
+            to_currency_id,
+            amount: is_reverse ? buyingAmount : sellingAmount,
+            is_reverse,
+            is_subtract,
+            to_address,
+            signal: abortControllerRef.current.signal,
+        };
+        if (!calcParams.amount) {
+            resetOrderCalc();
+            return;
+        }
+        try {
+            is_reverse ? setIsSellingValuePending(true) : setIsBuyingValuePending(true);
+            const data = await calcHandler(calcParams);
+            setCalcData({
+                ...data,
+                is_reverse,
+                is_subtract,
+            });
+            setSellingAmount(data.from_amount);
+            setBuyingAmount(data.result_amount);
+            abortControllerRef.current = null;
+            is_reverse ? setIsSellingValuePending(false) : setIsBuyingValuePending(false);
+        }
+        catch (error) {
+            if (error.code === 'ERR_CANCELED') {
+                return;
+            }
+            is_reverse ? setIsSellingValuePending(false) : setIsBuyingValuePending(false);
+            if (error.status === 404) {
+                // eslint-disable-next-line no-console
+                console.error('Rate not found');
+                resetOrderCalc();
+            }
+            throw error;
+        }
+    };
+    const onSellingValueUpdate = debounce((value) => {
+        if (value !== calcData?.from_amount || isBuyingValuePending) {
+            updateCalculations({ is_reverse: false, is_subtract: true });
+        }
+    }, abortControllerRef.current?.signal ? undefined : 1000);
+    const onBuyingValueUpdate = debounce((value) => {
+        if (value !== calcData?.result_amount || isSellingValuePending) {
+            updateCalculations({ is_reverse: true, is_subtract: false });
+        }
+    }, abortControllerRef.current?.signal ? undefined : 1000);
+    const onToAddressUpdate = debounce(() => {
+        updateCalculations({ is_reverse: false, is_subtract: true });
+    }, abortControllerRef.current?.signal ? undefined : 1000);
+    useEffect(() => {
+        abortCurrentCalculation();
+        updateCalculations({ is_reverse: false, is_subtract: true });
+    }, [from_currency_id, to_currency_id]);
+    useEffect(() => {
+        abortCurrentCalculation();
+        onSellingValueUpdate(sellingAmount);
+        return onSellingValueUpdate.cancel;
+    }, [sellingAmount]);
+    useEffect(() => {
+        abortCurrentCalculation();
+        onBuyingValueUpdate(buyingAmount);
+        return onBuyingValueUpdate.cancel;
+    }, [buyingAmount]);
+    useEffect(() => {
+        abortCurrentCalculation();
+        onToAddressUpdate();
+        return onToAddressUpdate.cancel;
+    }, [to_address]);
+    return {
+        sellingAmount,
+        setSellingAmount,
+        buyingAmount,
+        setBuyingAmount,
+        calcData,
+        isSellingValuePending,
+        isBuyingValuePending,
+    };
+};

package/dist/hooks/useFileUpload.d.ts

@@ -0,0 +1,49 @@
+import { UploadFileResult } from '../utils/fileStorage';
+interface UseFileUploadOptions {
+    bucket: string;
+    folder?: string;
+    authToken?: string;
+    onSuccess?: (result: UploadFileResult) => void;
+    onError?: (error: string) => void;
+}
+interface UseFileUploadReturn {
+    upload: (file: File, fileName?: string) => Promise<UploadFileResult>;
+    uploading: boolean;
+    progress: number;
+    error: string | null;
+    result: UploadFileResult | null;
+    reset: () => void;
+}
+/**
+ * React хук для загрузки файлов в Supabase Storage
+ *
+ * Папки создаются автоматически при загрузке файла, если их не существует.
+ *
+ * @example
+ * ```tsx
+ * // Загрузка в корень бакета
+ * const { upload, uploading, error, result } = useFileUpload({
+ *   bucket: 'user-files',
+ *   onSuccess: (result) => console.log('Загружено:', result.path),
+ * });
+ *
+ * // Загрузка в конкретную папку (папка создастся автоматически)
+ * const { upload } = useFileUpload({
+ *   bucket: 'documents',
+ *   folder: 'invoices', // файл будет загружен в invoices/
+ * });
+ *
+ * // Загрузка во вложенную папку (все папки создадутся автоматически)
+ * const { upload } = useFileUpload({
+ *   bucket: 'images',
+ *   folder: 'avatars/2024', // файл будет загружен в avatars/2024/
+ * });
+ *
+ * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) await upload(file);
+ * };
+ * ```
+ */
+export declare const useFileUpload: (options: UseFileUploadOptions) => UseFileUploadReturn;
+export {};

package/dist/hooks/useFileUpload.js

@@ -0,0 +1,100 @@
+import { useState, useCallback } from 'react';
+import { uploadFile } from '../utils/fileStorage';
+/**
+ * React хук для загрузки файлов в Supabase Storage
+ *
+ * Папки создаются автоматически при загрузке файла, если их не существует.
+ *
+ * @example
+ * ```tsx
+ * // Загрузка в корень бакета
+ * const { upload, uploading, error, result } = useFileUpload({
+ *   bucket: 'user-files',
+ *   onSuccess: (result) => console.log('Загружено:', result.path),
+ * });
+ *
+ * // Загрузка в конкретную папку (папка создастся автоматически)
+ * const { upload } = useFileUpload({
+ *   bucket: 'documents',
+ *   folder: 'invoices', // файл будет загружен в invoices/
+ * });
+ *
+ * // Загрузка во вложенную папку (все папки создадутся автоматически)
+ * const { upload } = useFileUpload({
+ *   bucket: 'images',
+ *   folder: 'avatars/2024', // файл будет загружен в avatars/2024/
+ * });
+ *
+ * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) await upload(file);
+ * };
+ * ```
+ */
+export const useFileUpload = (options) => {
+    const { bucket, folder, authToken, onSuccess, onError } = options;
+    const [uploading, setUploading] = useState(false);
+    const [progress, setProgress] = useState(0);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const upload = useCallback(async (file, customFileName) => {
+        setUploading(true);
+        setProgress(0);
+        setError(null);
+        setResult(null);
+        try {
+            // Симулируем прогресс (Supabase не предоставляет реальный progress)
+            const progressInterval = setInterval(() => {
+                setProgress((prev) => Math.min(prev + 10, 90));
+            }, 100);
+            const uploadOptions = {
+                file,
+                fileName: customFileName || `${Date.now()}-${file.name}`,
+                bucket,
+                folder,
+                contentType: file.type,
+                authToken,
+            };
+            const uploadResult = await uploadFile(uploadOptions);
+            clearInterval(progressInterval);
+            setProgress(100);
+            setResult(uploadResult);
+            if (uploadResult.success) {
+                onSuccess?.(uploadResult);
+            }
+            else {
+                const errorMsg = uploadResult.error || 'Ошибка загрузки файла';
+                setError(errorMsg);
+                onError?.(errorMsg);
+            }
+            return uploadResult;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : 'Непредвиденная ошибка';
+            setError(errorMsg);
+            onError?.(errorMsg);
+            setProgress(0);
+            return {
+                success: false,
+                error: errorMsg,
+            };
+        }
+        finally {
+            setUploading(false);
+        }
+    }, [bucket, folder, authToken, onSuccess, onError]);
+    const reset = useCallback(() => {
+        setUploading(false);
+        setProgress(0);
+        setError(null);
+        setResult(null);
+    }, []);
+    return {
+        upload,
+        uploading,
+        progress,
+        error,
+        result,
+        reset,
+    };
+};

package/dist/hooks/useSupabaseSubscription/config.d.ts

@@ -0,0 +1,2 @@
+import { SubscriptionConfig } from './types';
+export declare const createWalletTransactionsConfig: (walletId: string) => SubscriptionConfig;

package/dist/hooks/useSupabaseSubscription/config.js

@@ -0,0 +1,5 @@
+export const createWalletTransactionsConfig = (walletId) => ({
+    channelName: `wallet-transactions-${walletId}`,
+    table: 'transactions',
+    filter: `wallet_id=eq.${walletId}`,
+});

package/dist/hooks/useSupabaseSubscription/index.js

@@ -0,0 +1,2 @@
+export { useSupabaseSubscription } from './useSupabaseSubscription';
+export { useWalletTransactionsSubscription } from './specialized';

package/dist/hooks/useSupabaseSubscription/specialized.d.ts

@@ -0,0 +1,5 @@
+import { UseWalletTransactionsSubscriptionProps } from './types';
+export declare const useWalletTransactionsSubscription: ({ walletId, ...props }: UseWalletTransactionsSubscriptionProps) => {
+    isConnected: boolean;
+    isClientAvailable: boolean;
+};

package/{src/hooks/useSupabaseSubscription/specialized.ts → dist/hooks/useSupabaseSubscription/specialized.js}

@@ -1,9 +1,6 @@
 import { createWalletTransactionsConfig } from './config';
-import { UseWalletTransactionsSubscriptionProps } from './types';
 import { useSupabaseSubscription } from './useSupabaseSubscription';
-
-export const useWalletTransactionsSubscription = ({ walletId, ...props }: UseWalletTransactionsSubscriptionProps) =>
-  useSupabaseSubscription({
+export const useWalletTransactionsSubscription = ({ walletId, ...props }) => useSupabaseSubscription({
     ...props,
     config: createWalletTransactionsConfig(walletId || ''),
-  });
+});