@orderly.network/hooks 1.5.13 → 2.0.0-alpha.0

package/dist/index.d.mts

@@ -0,0 +1,1371 @@
+import useSWR, { SWRConfiguration, SWRResponse } from 'swr';
+export { SWRConfig, SWRConfiguration, unstable_serialize, default as useSWR, useSWRConfig } from 'swr';
+import { SWRMutationConfiguration, SWRMutationResponse } from 'swr/mutation';
+import * as swr_infinite from 'swr/infinite';
+import { SWRInfiniteKeyLoader, SWRInfiniteConfiguration } from 'swr/infinite';
+import * as swr__internal from 'swr/_internal';
+import * as _orderly_network_core from '@orderly.network/core';
+import { AccountState, Account, EventEmitter, ConfigStore, ConfigKey, SimpleDI, OrderlyKeyStore, getWalletAdapterFunc, WalletAdapter, IContract } from '@orderly.network/core';
+export { WalletAdapter } from '@orderly.network/core';
+export { default as useConstant } from 'use-constant';
+import { WS } from '@orderly.network/net';
+import * as react from 'react';
+import { PropsWithChildren } from 'react';
+import * as _orderly_network_types from '@orderly.network/types';
+import { API, NetworkId, Chain as Chain$1, ChainNamespace, OrderEntity, OrderSide, WSMessage, OrderStatus, AlgoOrderRootType, AlgoOrderEntity, AlgoOrderType } from '@orderly.network/types';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { EIP1193Provider } from '@web3-onboard/common';
+import * as swr_subscription from 'swr/subscription';
+import { Decimal } from '@orderly.network/utils';
+export * from 'use-debounce';
+
+declare global {
+    interface Window {
+        __ORDERLY_VERSION__?: {
+            [key: string]: string;
+        };
+    }
+}
+declare const _default: "2.0.0-alpha.0";
+
+type useQueryOptions<T> = SWRConfiguration & {
+    formatter?: (data: any) => T;
+};
+
+/**
+ * useQuery
+ * @description for public api
+ * @param query
+ * @param options
+ */
+declare const useQuery: <T>(query: Parameters<typeof useSWR>["0"], options?: useQueryOptions<T> | undefined) => SWRResponse<T, any, any>;
+
+/**
+ * useQuery
+ * @description for public api
+ * @param query
+ * @param options
+ */
+declare const useLazyQuery: <T, R = any>(query: Parameters<typeof useSWR>["0"], options?: (SWRMutationConfiguration<any, any> & {
+    formatter?: ((data: any) => R) | undefined;
+    init?: RequestInit | undefined;
+}) | undefined) => SWRMutationResponse;
+
+type HTTP_METHOD = "POST" | "PUT" | "DELETE" | "GET";
+/**
+ * This hook is used to execute API requests for data mutation, such as POST, DELETE, PUT, etc.
+ */
+declare const useMutation: <T, E>(url: string, method?: HTTP_METHOD, options?: SWRMutationConfiguration<T, E> | undefined) => readonly [(data: Record<string, any> | null, params?: Record<string, any>, options?: SWRMutationConfiguration<T, E> | undefined) => Promise<any>, {
+    readonly data: any;
+    readonly error: E | undefined;
+    readonly reset: () => void;
+    readonly isMutating: boolean;
+}];
+
+/**
+ * usePrivateQuery
+ * @description for private api
+ * @param query
+ * @param options
+ */
+declare const usePrivateQuery: <T>(query: string, options?: useQueryOptions<T> | undefined) => SWRResponse<T, any, any>;
+
+declare const usePrivateInfiniteQuery: <T>(getKey: SWRInfiniteKeyLoader, options?: (SWRInfiniteConfiguration<any, any, swr__internal.BareFetcher<any>> & {
+    formatter?: ((data: any) => any) | undefined;
+}) | undefined) => swr_infinite.SWRInfiniteResponse<T, any>;
+
+declare const useBoolean: (initialValue?: boolean) => [boolean, {
+    setTrue: () => void;
+    setFalse: () => void;
+    toggle: () => void;
+}];
+
+declare const useAccount: () => {
+    account: _orderly_network_core.Account;
+    state: AccountState;
+    createOrderlyKey: (remember: boolean) => Promise<any>;
+    createAccount: () => Promise<any>;
+};
+
+declare const useAccountInstance: () => Account;
+
+declare const usePreLoadData: () => {
+    error: any;
+    done: boolean;
+};
+
+declare const useEventEmitter: () => EventEmitter<string | symbol, any>;
+
+declare function useSessionStorage<T>(key: string, initialValue: T): [T, (data: any) => void];
+
+declare function useLocalStorage<T>(key: string, initialValue: T): [any, (value: T) => void];
+
+declare function parseJSON<T>(value: string | null): T | undefined;
+
+declare const useWS: () => WS;
+
+declare function useConfig(): ConfigStore;
+declare function useConfig<T = string>(key: ConfigKey, defaultValue?: T): T;
+
+declare const useKeyStore: () => _orderly_network_core.OrderlyKeyStore;
+
+declare const useSimpleDI: <T>() => {
+    get: (name: string) => T;
+    register: typeof SimpleDI.register;
+};
+
+type Chain = API.Chain & {
+    nativeToken?: API.TokenInfo;
+    isTestnet?: boolean;
+};
+type Chains<T extends NetworkId | undefined = undefined, K extends keyof API.Chain | undefined = undefined> = T extends NetworkId ? K extends keyof API.Chain ? API.Chain[K][] : API.Chain[] : K extends keyof API.Chain ? {
+    testnet: API.Chain[K][];
+    mainnet: API.Chain[K][];
+} : {
+    testnet: API.Chain[];
+    mainnet: API.Chain[];
+};
+type UseChainsOptions = {
+    filter?: (item: API.Chain) => boolean;
+    pick?: "dexs" | "network_infos" | "token_infos";
+    forceAPI?: boolean;
+} & SWRConfiguration;
+type UseChainsReturnObject = {
+    findByChainId: (chainId: number, field?: string) => Chain | undefined;
+    checkChainSupport: (chainId: number | string, networkId: NetworkId) => boolean;
+    error: any;
+};
+declare function useChains(networkId?: undefined, options?: undefined): [Chains<undefined, undefined>, UseChainsReturnObject];
+declare function useChains<T extends NetworkId | undefined, K extends UseChainsOptions | undefined>(networkId?: T, options?: K): [
+    Chains<T, K extends UseChainsOptions ? K["pick"] extends keyof API.Chain ? K["pick"] : undefined : undefined>,
+    UseChainsReturnObject
+];
+
+type filteredChains$1 = {
+    mainnet?: Chain$1[];
+    testnet?: Chain$1[];
+};
+type chainFilterFunc = (config: ConfigStore) => filteredChains$1;
+type chainFilter = filteredChains$1 | chainFilterFunc;
+interface OrderlyConfigContextState {
+    fetcher?: (url: string, init: RequestInit) => Promise<any>;
+    configStore: ConfigStore;
+    keyStore: OrderlyKeyStore;
+    getWalletAdapter: getWalletAdapterFunc;
+    walletAdapters: WalletAdapter[];
+    networkId: NetworkId;
+    /**
+     * @hidden
+     */
+    onlyTestnet?: boolean;
+    filteredChains?: filteredChains$1 | null;
+    customChains?: Chains<undefined, undefined>;
+}
+declare const OrderlyContext: react.Context<OrderlyConfigContextState>;
+declare const OrderlyProvider: react.Provider<OrderlyConfigContextState>;
+
+declare enum WsNetworkStatus {
+    Connected = "connected",
+    Unstable = "unstable",
+    Disconnected = "disconnected"
+}
+declare function useWsStatus(): WsNetworkStatus;
+
+interface StatusContextState {
+    ws?: WsNetworkStatus;
+}
+declare const StatusContext: react.Context<StatusContextState>;
+declare const StatusProvider: React.FC<PropsWithChildren>;
+
+type RequireAtLeastOne<T, R extends keyof T = keyof T> = Omit<T, R> & {
+    [K in R]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<R, K>>>;
+}[R];
+type filteredChains = {
+    mainnet?: Chain$1[];
+    testnet?: Chain$1[];
+};
+type filterChainsFunc = (config: ConfigStore) => filteredChains;
+interface ConfigProviderProps {
+    configStore?: ConfigStore;
+    keyStore?: OrderlyKeyStore;
+    contracts?: IContract;
+    getWalletAdapter?: getWalletAdapterFunc;
+    walletAdapters: WalletAdapter[];
+    brokerId: string;
+    brokerName: string;
+    networkId: NetworkId;
+    chainFilter?: filteredChains | filterChainsFunc;
+    customChains?: Chains<undefined, undefined>;
+}
+declare const OrderlyConfigProvider: (props: PropsWithChildren<RequireAtLeastOne<ConfigProviderProps, "brokerId" | "configStore">>) => react_jsx_runtime.JSX.Element | null;
+
+type ConnectedChain = {
+    id: number | string;
+    namespace: ChainNamespace;
+};
+type WalletAccount = {
+    address: string;
+};
+interface WalletState {
+    label: string;
+    icon: string;
+    provider: EIP1193Provider;
+    accounts: WalletAccount[];
+    chains: ConnectedChain[];
+    instance?: unknown;
+}
+interface WalletConnectorContextState {
+    connect: (options?: any) => Promise<WalletState[]>;
+    disconnect: (options: any) => Promise<any[]>;
+    connecting: boolean;
+    setChain: (options: {
+        chainId: string | number;
+    }) => Promise<any>;
+    chains: any[];
+    wallet: WalletState;
+    connectedChain: ConnectedChain | null;
+    settingChain: boolean;
+}
+declare const WalletConnectorContext: react.Context<WalletConnectorContextState>;
+declare const useWalletConnector: () => WalletConnectorContextState;
+
+type OrderBookItem = number[];
+type OrderbookData = {
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+};
+/**
+ * Configuration for the Order Book
+ */
+type OrderbookOptions = {
+    /** Indicates the number of data entries to return for ask/bid, default is 10 */
+    level?: number;
+    /** Whether to fill in when the actual data entries are less than the level. If filled, it will add [nan, nan, nan, nan]. Default is true */
+    padding?: boolean;
+};
+/**
+ * @name useOrderbookStream
+ * @description React hook that returns the current orderbook for a given market
+ */
+declare const useOrderbookStream: (symbol: string, initial?: OrderbookData, options?: OrderbookOptions) => ({
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+    markPrice: number;
+    middlePrice: number[];
+    onDepthChange?: undefined;
+    depth?: undefined;
+    allDepths?: undefined;
+    isLoading?: undefined;
+    onItemClick?: undefined;
+} | {
+    onDepthChange: (depth: number) => void;
+    depth: number | undefined;
+    allDepths: any[];
+    isLoading: boolean;
+    onItemClick: (item: OrderBookItem) => void;
+    asks?: undefined;
+    bids?: undefined;
+    markPrice?: undefined;
+    middlePrice?: undefined;
+})[];
+
+type UseOrderEntryOptions = {
+    commify?: boolean;
+    watchOrderbook?: boolean;
+    validate?: (data: OrderEntity) => {
+        [P in keyof OrderEntity]?: string;
+    } | null | undefined;
+};
+type UseOrderEntryMetaState = {
+    errors: {
+        [P in keyof OrderEntity]?: {
+            type: string;
+            message: string;
+        };
+    } | null | undefined;
+    dirty: {
+        [P in keyof OrderEntity]?: boolean;
+    } | null | undefined;
+    submitted: boolean;
+};
+type UseOrderEntryReturn = {
+    maxQty: number;
+    freeCollateral: number;
+    markPrice: number;
+    estLiqPrice?: number | null;
+    estLeverage?: number | null;
+    onSubmit: (order: OrderEntity) => Promise<any>;
+    submit: () => Promise<OrderEntity>;
+    submitting: boolean;
+    formattedOrder: Partial<OrderEntity>;
+    helper: {
+        calculate: (values: Partial<OrderEntity>, field: keyof OrderEntity, value: any) => Partial<OrderEntity>;
+        validator: (values: Partial<OrderEntity>) => any;
+    };
+    metaState: UseOrderEntryMetaState;
+    symbolConfig: API.SymbolExt;
+};
+type OrderParams = Required<Pick<OrderEntity, "side" | "order_type" | "symbol">> & Partial<Omit<OrderEntity, "side" | "symbol" | "order_type">>;
+/**
+ * Create Order
+ * @example
+ * ```tsx
+ * import { useOrderEntry } from "@orderly.network/hooks";
+ * import {OrderSide, OrderType} from '@orderly.network/types';
+ *
+ * const { formattedOrder, onSubmit, helper } = useOrderEntry({
+ *  symbol: "PERP_ETH_USDC",
+ *  side: OrderSide.BUY,
+ *  order_type: OrderType.LIMIT,
+ *  order_price: 10000,
+ *  order_quantity: 1,
+ * },{
+ *  // **Note:** it's required
+ *  watchOrderbook: true,
+ * });
+ * ```
+ */
+declare function useOrderEntry(order: OrderParams, options?: UseOrderEntryOptions): UseOrderEntryReturn;
+/**
+ * @deprecated
+ */
+declare function useOrderEntry(symbol: string, side: OrderSide, reduceOnly: boolean): UseOrderEntryReturn;
+
+type ValueOf<T> = T[keyof T];
+
+type SymbolInfo = ReturnType<typeof useSymbolsInfo>;
+declare const useSymbolsInfo: () => {
+    [x: string]: (key?: keyof API.SymbolExt | undefined, defaultValue?: ValueOf<API.SymbolExt> | undefined) => any;
+} & {
+    isNil: boolean;
+};
+
+declare const useAccountInfo: () => swr__internal.SWRResponse<API.AccountInfo, any, any>;
+
+declare const useMarketsStream: () => {
+    data: WSMessage.Ticker[] | null;
+};
+
+declare enum MarketsType$1 {
+    FAVORITES = 0,
+    RECENT = 1,
+    ALL = 2
+}
+interface FavoriteTab$1 {
+    name: string;
+    id: number;
+}
+interface Favorite {
+    name: string;
+    tabs: FavoriteTab$1[];
+}
+interface Recent$1 {
+    name: string;
+}
+interface TabSort$1 {
+    sortKey: string;
+    sortOrder: string;
+}
+declare const useMarkets: (type: MarketsType$1) => readonly [any[], {
+    readonly favoriteTabs: {
+        name: string;
+        id: number;
+    }[];
+    readonly favorites: Favorite[];
+    readonly recent: Recent$1[];
+    readonly tabSort: Record<string, TabSort$1>;
+    readonly addToHistory: (symbol: API.MarketInfoExt) => void;
+    readonly updateFavorites: (favorites: Favorite[]) => void;
+    readonly updateFavoriteTabs: (tab: FavoriteTab$1 | FavoriteTab$1[], operator?: {
+        add?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    }) => void;
+    readonly updateSymbolFavoriteState: (symbol: API.MarketInfoExt, tab: FavoriteTab$1 | FavoriteTab$1[], remove?: boolean) => void;
+    readonly pinToTop: (symbol: API.MarketInfoExt) => void;
+    readonly getLastSelFavTab: () => FavoriteTab$1;
+    readonly updateSelectedFavoriteTab: (tab: FavoriteTab$1) => void;
+    readonly updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
+}];
+
+declare enum MarketsType {
+    FAVORITES = 0,
+    RECENT = 1,
+    ALL = 2
+}
+interface FavoriteTab {
+    name: string;
+    id: number;
+}
+interface Recent {
+    name: string;
+}
+type TabSort = Record<string, {
+    sortKey: string;
+    sortOrder: string;
+}>;
+type MarketsItem = {
+    symbol: string;
+    index_price: number;
+    mark_price: number;
+    sum_unitary_funding: number;
+    est_funding_rate: number;
+    last_funding_rate: number;
+    next_funding_time: number;
+    open_interest: number;
+    "24h_open": number;
+    "24h_close": number;
+    "24h_high": number;
+    "24h_low": number;
+    "24h_volume": number;
+    "24h_amount": number;
+    "24h_volumn": number;
+    change: number;
+    "8h_funding": number;
+    quote_dp: number;
+    created_time: number;
+    openInterest: number;
+    isFavorite: boolean;
+    leverage?: number;
+};
+declare const MarketsStorageKey = "markets";
+declare const useMarketList: (type: MarketsType) => readonly [MarketsItem[], {
+    readonly favoriteTabs: FavoriteTab[];
+    readonly favorites: {
+        tabs: FavoriteTab[];
+        name: string;
+    }[];
+    readonly recent: Recent[];
+    readonly tabSort: TabSort;
+    readonly selectedFavoriteTab: FavoriteTab;
+    readonly updateFavorites: react.Dispatch<react.SetStateAction<{
+        tabs: FavoriteTab[];
+        name: string;
+    }[]>>;
+    readonly updateFavoriteTabs: (tab: FavoriteTab | FavoriteTab[], operator?: {
+        add?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    }) => void;
+    readonly updateSymbolFavoriteState: (symbol: API.MarketInfoExt, tab: FavoriteTab | FavoriteTab[], remove?: boolean) => void;
+    readonly pinToTop: (symbol: API.MarketInfoExt) => void;
+    readonly addToHistory: (symbol: API.MarketInfoExt) => void;
+    readonly updateSelectedFavoriteTab: react.Dispatch<react.SetStateAction<FavoriteTab>>;
+    readonly updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
+}];
+
+declare const useMarkPricesStream: () => swr_subscription.SWRSubscriptionResponse<Record<string, number>, any>;
+
+declare const useMarkPrice: (symbol: string) => {
+    data: number;
+};
+
+declare const useIndexPrice: (symbol: string) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useLeverage: () => any;
+
+declare const useTickerStream: (symbol: string) => API.MarketInfo & {
+    change?: Decimal | undefined;
+    "24h_change"?: Decimal | undefined;
+};
+
+declare const useFundingRate: (symbol: string) => {
+    est_funding_rate: string | null | undefined;
+    countDown: string;
+    symbol?: string | undefined;
+    est_funding_rate_timestamp?: number | undefined;
+    last_funding_rate?: number | undefined;
+    last_funding_rate_timestamp?: number | undefined;
+    next_funding_time?: number | undefined;
+    sum_unitary_funding?: number | undefined;
+};
+
+declare const useFundingRates: () => {
+    [x: string]: (key?: keyof API.FundingRate | undefined, defaultValue?: ValueOf<API.FundingRate> | undefined) => any;
+} & {
+    isNil: boolean;
+};
+
+type PriceMode = "markPrice" | "lastPrice";
+declare const usePositionStream: (symbol?: string, options?: SWRConfiguration & {
+    calcMode?: PriceMode;
+    /**
+     * If true, the pending order will be included in the result.
+     */
+    includedPendingOrder?: boolean;
+}) => readonly [{
+    readonly rows: API.PositionTPSLExt[] | null;
+    readonly aggregated: any;
+    readonly totalCollateral: Decimal;
+    readonly totalValue: Decimal;
+    readonly totalUnrealizedROI: number;
+}, {
+    margin_ratio: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    initial_margin_ratio: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    maintenance_margin_ratio: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    open_margin_ratio: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    current_margin_ratio_with_orders: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    initial_margin_ratio_with_orders: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    maintenance_margin_ratio_with_orders: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    total_collateral_value: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    free_collateral: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+    total_pnl_24_h: (key?: "margin_ratio" | "initial_margin_ratio" | "maintenance_margin_ratio" | "open_margin_ratio" | "current_margin_ratio_with_orders" | "initial_margin_ratio_with_orders" | "maintenance_margin_ratio_with_orders" | "total_collateral_value" | "free_collateral" | "total_pnl_24_h" | undefined, defaultValue?: number | undefined) => any;
+} & {
+    isNil: boolean;
+}, {
+    /**
+     * @deprecated use `isLoading` instead
+     */
+    readonly loading: boolean;
+    readonly isLoading: boolean;
+    readonly isValidating: boolean;
+    readonly error: any;
+    readonly refresh: swr__internal.KeyedMutator<API.PositionInfo>;
+}];
+
+type CombineOrderType = AlgoOrderRootType | "ALL";
+declare const useOrderStream: (params: {
+    symbol?: string;
+    status?: OrderStatus;
+    page?: number;
+    size?: number;
+    side?: OrderSide;
+    /**
+     * Include the order type
+     * @default ["ALL"]
+     */
+    includes?: CombineOrderType[];
+    /**
+     * Exclude the order type
+     * @default []
+     */
+    excludes?: CombineOrderType[];
+    dateRange?: {
+        from?: Date;
+        to?: Date;
+    };
+}, options?: {
+    /**
+     * Keep the state update alive
+     */
+    keeplive?: boolean;
+    /**
+     * Stop the state update when the component unmount
+     */
+    stopOnUnmount?: boolean;
+}) => readonly [any[] | null, {
+    readonly total: number;
+    readonly isLoading: boolean;
+    readonly refresh: swr__internal.KeyedMutator<unknown[]>;
+    readonly loadMore: () => void;
+    readonly cancelAllOrders: () => Promise<[any, any]>;
+    readonly cancelAllTPSLOrders: () => Promise<any[]>;
+    readonly cancelAlgoOrdersByTypes: (types: AlgoOrderRootType[]) => Promise<any[]>;
+    readonly updateOrder: (orderId: string, order: OrderEntity) => Promise<any>;
+    readonly cancelOrder: (orderId: number, symbol?: string) => Promise<any>;
+    readonly updateAlgoOrder: (orderId: string, order: OrderEntity) => Promise<any>;
+    readonly cancelAlgoOrder: (orderId: number, symbol?: string) => Promise<any>;
+    readonly cancelTPSLChildOrder: (orderId: number, rootAlgoOrderId: number) => Promise<any>;
+    readonly updateTPSLOrder: (orderId: number, childOrders: API.AlgoOrder["child_orders"]) => Promise<any>;
+    readonly meta: any;
+    readonly errors: {
+        readonly cancelOrder: unknown;
+        readonly updateOrder: unknown;
+        readonly cancelAlgoOrder: unknown;
+        readonly updateAlgoOrder: unknown;
+    };
+    readonly submitting: {
+        readonly cancelOrder: boolean;
+        readonly updateOrder: boolean;
+        readonly cancelAlgoOrder: boolean;
+        readonly updateAlglOrder: boolean;
+    };
+}];
+
+interface MarketTradeStreamOptions {
+    limit?: number;
+}
+declare const useMarketTradeStream: (symbol: string, options?: MarketTradeStreamOptions) => {
+    data: API.Trade[];
+    isLoading: boolean;
+};
+
+type CollateralOutputs = {
+    totalCollateral: number;
+    freeCollateral: number;
+    totalValue: number;
+    availableBalance: number;
+    unsettledPnL: number;
+    positions: API.Position[];
+    accountInfo?: API.AccountInfo;
+};
+declare const useCollateral: (options?: {
+    /** decimal precision */
+    dp: number;
+}) => CollateralOutputs;
+
+/**
+ * @param symbol
+ * @param side
+ * @param reduceOnly
+ * @returns the maximum quantity available for trading in USD
+ */
+declare const useMaxQty: (symbol: string, side: OrderSide, reduceOnly?: boolean) => number;
+
+type MarginRatioReturn = {
+    marginRatio: number;
+    currentLeverage: number;
+    mmr: number | null;
+};
+declare const useMarginRatio: () => MarginRatioReturn;
+
+declare const useChain: (token: string) => {
+    chains: API.Chain | null;
+    isLoading: boolean;
+};
+
+type UseWithdrawOptions = {
+    srcChainId?: number;
+};
+declare const useWithdraw: (options?: UseWithdrawOptions) => {
+    dst: {
+        symbol: string;
+        decimals: number;
+        address: string | undefined;
+        chainId: number;
+        network: string;
+    };
+    withdraw: (inputs: {
+        chainId: number;
+        token: string;
+        amount: string;
+        allowCrossChainWithdraw: boolean;
+    }) => Promise<any>;
+    isLoading: boolean;
+    maxAmount: number;
+    availableBalance: number;
+    availableWithdraw: number;
+    unsettledPnL: number;
+};
+
+type useDepositOptions = {
+    address?: string;
+    decimals?: number;
+    networkId?: NetworkId;
+    srcChainId?: number;
+    srcToken?: string;
+    quantity?: string;
+};
+declare const useDeposit: (options?: useDepositOptions) => {
+    /** orderly support chain dst */
+    dst: {
+        symbol: string;
+        address: string | undefined;
+        decimals: number | undefined;
+        chainId: number;
+        network: string;
+    };
+    balance: string;
+    allowance: string;
+    isNativeToken: boolean;
+    balanceRevalidating: boolean;
+    allowanceRevalidating: boolean;
+    /** input quantiy */
+    quantity: string;
+    /** orderly deposit fee, unit: wei */
+    depositFee: bigint;
+    /** enquiring depositFee status on chain */
+    depositFeeRevalidating: boolean;
+    approve: (amount?: string) => Promise<void | undefined>;
+    deposit: () => Promise<any>;
+    fetchBalances: (tokens: API.TokenInfo[]) => Promise<void>;
+    fetchBalance: (address: string, decimals?: number) => Promise<string>;
+    /** set input quantity */
+    setQuantity: react.Dispatch<react.SetStateAction<string>>;
+};
+
+declare const useHoldingStream: () => {
+    data: API.Holding[] | undefined;
+    usdc: API.Holding | undefined;
+    isLoading: boolean;
+};
+
+declare const useWalletSubscription: (options?: {
+    onMessage?: ((data: any) => void) | undefined;
+} | undefined) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useSettleSubscription: (options?: {
+    onMessage?: ((data: any) => void) | undefined;
+} | undefined) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+type getKeyFunction = (index: number, prevData: any) => string | null;
+
+declare const usePrivateDataObserver: (options: {
+    getKeysMap: (type: string) => Map<string, getKeyFunction>;
+}) => void;
+
+type PriceRange = {
+    min: number;
+    max: number;
+};
+/**
+ * Get the price range for the specified symbol with an optional price
+ *
+ * @param symbol - The symbol to get the price range for
+ * @param price - Optional parameter to set the price
+ * @returns PriceRange | undefined - Returns the PriceRange representing the price range or undefined
+ */
+declare const useSymbolPriceRange: (symbol: string, side: "BUY" | "SELL", price?: number) => PriceRange | undefined;
+
+type ComputedAlgoOrder = Partial<AlgoOrderEntity<AlgoOrderRootType.TP_SL> & {
+    /**
+     * Computed take profit
+     */
+    tp_pnl: number;
+    tp_offset: number;
+    tp_offset_percentage: number;
+    /**
+     * Computed stop loss
+     */
+    sl_pnl: number;
+    sl_offset: number;
+    sl_offset_percentage: number;
+}>;
+type ValidateError = {
+    [P in keyof ComputedAlgoOrder]?: {
+        type: string;
+        message: string;
+    };
+};
+
+declare const useTPSLOrder: (position: Partial<API.PositionTPSLExt> & Pick<API.PositionTPSLExt, "symbol" | "average_open_price" | "position_qty">, options?: {
+    /**
+     * You can set the default value for the take profit and stop loss order,
+     * it is usually used when editing order
+     */
+    defaultOrder?: API.AlgoOrder;
+}) => [Partial<Omit<_orderly_network_types.BaseAlgoOrderEntity<_orderly_network_types.AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price"> & Partial<Pick<_orderly_network_types.BaseAlgoOrderEntity<_orderly_network_types.AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price">> & {
+    tp_pnl: number;
+    tp_offset: number;
+    tp_offset_percentage: number;
+    sl_pnl: number;
+    sl_offset: number;
+    sl_offset_percentage: number;
+}>, {
+    setValue: (key: string, value: string | number) => void;
+    setValues: (values: Partial<Partial<Omit<_orderly_network_types.BaseAlgoOrderEntity<_orderly_network_types.AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price"> & Partial<Pick<_orderly_network_types.BaseAlgoOrderEntity<_orderly_network_types.AlgoOrderRootType.TP_SL>, "type" | "side" | "order_type" | "trigger_price">> & {
+        tp_pnl: number;
+        tp_offset: number;
+        tp_offset_percentage: number;
+        sl_pnl: number;
+        sl_offset: number;
+        sl_offset_percentage: number;
+    }>>) => void;
+    submit: () => Promise<void>;
+    errors: ValidateError | null;
+    validate: () => Promise<_orderly_network_types.AlgoOrderEntity<_orderly_network_types.AlgoOrderRootType.TP_SL | _orderly_network_types.AlgoOrderRootType.POSITIONAL_TP_SL>>;
+    isCreateMutating: boolean;
+}];
+
+declare const useSymbolLeverage: (symbol: string) => number | "-";
+
+declare enum AssetHistoryStatusEnum {
+    NEW = "new",
+    CONFIRM = "confirm",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    PENDDING = "pendding",
+    PENDING_REBALANCE = "pending_rebalance"
+}
+declare const useAssetsHistory: (options: {
+    side?: string;
+    startTime?: string;
+    endTime?: string;
+    page?: number;
+    pageSize?: number;
+}) => readonly [API.AssetHistoryRow[], {
+    readonly meta: API.RecordsMeta | undefined;
+    readonly isLoading: boolean;
+}];
+
+type QueryParams = {
+    startDate: string;
+    endDate: string;
+    page?: number;
+};
+/**
+ * Fetch statistics data, only support weekly/monthly/quarterly for now
+ */
+declare const useStatisticsDaily: (params: QueryParams, options?: {
+    ignoreAggregation?: boolean;
+}) => readonly [API.DailyRow[], {
+    readonly aggregateValue: {
+        vol: null;
+        pnl: null;
+        roi: null;
+    } | {
+        vol: number;
+        pnl: number;
+        roi: number;
+    };
+}];
+
+type FundingSearchParams = {
+    /**
+     * Data range for the funding fee history
+     * noted that the time stamp is a 13-digits timestamp
+     * the first element is the start date and the second element is the end date
+     * @default [Now subtract 3 months, Now]
+     */
+    dataRange?: number[];
+    symbol?: string;
+    page?: number;
+    pageSize?: number;
+};
+declare const useFundingFeeHistory: (params: FundingSearchParams, options?: SWRConfiguration) => readonly [(API.FundingFeeRow & {
+    annual_rate: number;
+})[] | null, {
+    readonly meta: API.RecordsMeta | undefined;
+    readonly isLoading: boolean;
+    readonly isValidating: boolean;
+}];
+
+type DistributionSearchParams = {
+    /**
+     * Data range for the distribution history
+     * noted that the time stamp is a 13-digits timestamp
+     * the first element is the start date and the second element is the end date
+     * @default [Now subtract 3 months, Now]
+     */
+    dataRange?: number[];
+    type?: string;
+    page: number;
+    pageSize: number;
+};
+declare const useDistributionHistory: (parmas: DistributionSearchParams) => readonly [(API.FundingFeeRow & {
+    annual_rate: number;
+})[], {
+    readonly meta: API.RecordsMeta | undefined;
+    readonly isLoading: boolean;
+    readonly isValidating: boolean;
+}];
+
+declare function useMaintenanceStatus(): {
+    status: number;
+    brokerName: string;
+    startTime: number | undefined;
+    endTime: number | undefined;
+};
+
+declare function useMediaQuery(query: string): boolean;
+
+type posterDataSource = {
+    /**
+     * slogan of the poster
+     */
+    message?: string;
+    position: {
+        symbol: string;
+        side: "LONG" | "SHORT";
+        /**
+         * The leverage of the position
+         */
+        leverage: number;
+        /**
+         * The unrealized PnL of the position
+         */
+        pnl: number;
+        /**
+         * The return on investment of the position
+         */
+        ROI: number;
+        /**
+         * The informations of the position, such as open price, opened at, mark price, quantity and custom message.
+         */
+        informations: {
+            title: string;
+            value: string;
+        }[];
+        /**
+         * The quote currency of the position
+         */
+        currency: string;
+    };
+    /**
+     * The domain of the application
+     */
+    domain: string;
+    /**
+     * The update time of the position
+     */
+    updateTime: string;
+    referral?: {
+        code: string;
+        slogan: string;
+        link: string;
+    } | null;
+};
+type layoutInfo = {
+    width?: number;
+    height?: number;
+    fontSize?: number;
+    color?: string;
+    textAlign?: CanvasTextAlign;
+    textBaseline?: CanvasTextBaseline;
+    position: Partial<{
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }>;
+};
+type PosterLayoutConfig = {
+    message?: layoutInfo;
+    domain?: layoutInfo;
+    position?: layoutInfo;
+    unrealizedPnl?: layoutInfo & {
+        secondaryColor: string;
+        secondaryFontSize: number;
+    };
+    informations?: layoutInfo & {
+        labelColor?: string;
+    };
+    updateTime?: layoutInfo;
+};
+type DrawOptions = {
+    /**
+     * Color of common text
+     */
+    color?: string;
+    fontFamily?: string;
+    /**
+     * Lose color
+     */
+    lossColor?: string;
+    /**
+     * Profit color
+     */
+    profitColor?: string;
+    /**
+     * The brand color of the application
+     */
+    brandColor?: string;
+    backgroundColor?: string;
+    backgroundImg?: string;
+    data?: posterDataSource;
+    layout?: PosterLayoutConfig;
+};
+
+/**
+ * Generates a poster image based on position information. You can set the size, background color, font color, font size, and content position of the poster.
+ * @example
+ * ```tsx
+ * const { ref, toDataURL, toBlob, download, copy } = usePoster({
+ *   backgroundColor: "#0b8c70",
+ *   backgroundImg: "/images/poster_bg.png",
+ *   color: "rgba(255, 255, 255, 0.98)",
+ *   profitColor: "rgb(0,181,159)",
+ *   // ...
+ * });
+ * ```
+ */
+declare const usePoster: (data: DrawOptions, options?: {
+    /**
+     * The ratio of the poster
+     */
+    ratio?: number;
+}) => {
+    readonly error: Error | null;
+    /**
+     * The ref to the canvas element, you should pass this ref to the canvas element
+     */
+    readonly ref: (ref: HTMLCanvasElement | null) => void;
+    /**
+     * Converts the poster to a data URL
+     */
+    readonly toDataURL: (type?: string, encoderOptions?: number) => string;
+    /**
+     * Converts the poster to a blob
+     */
+    readonly toBlob: (type?: string, encoderOptions?: number) => Promise<Blob | null>;
+    /**
+     * Downloads the poster as an image
+     */
+    readonly download: (filename: string, type?: string, encoderOptions?: number) => void;
+    /**
+     * Browser if supports copy image to clipboard
+     */
+    readonly canCopy: boolean;
+    readonly copy: () => Promise<void>;
+};
+
+declare const DefaultLayoutConfig: PosterLayoutConfig;
+
+declare const cleanStringStyle: (str: string | number) => string;
+declare function formatNumber(qty?: string | number, dp?: number | string): string | undefined;
+
+declare function checkNotional(price?: string | number, qty?: string | number, minNotional?: number): string | undefined;
+
+declare const findTPSLFromOrders: (orders: API.AlgoOrder[], symbol: string) => Partial<AlgoOrderEntity> | undefined;
+declare const findTPSLFromOrder: (order: API.AlgoOrder) => {
+    tp_trigger_price?: number | undefined;
+    sl_trigger_price?: number | undefined;
+};
+declare const findPositionTPSLFromOrders: (orders: API.AlgoOrder[], symbol: string) => API.AlgoOrder | undefined;
+
+declare function getPositionBySymbol(symbol: string): void;
+
+/**
+ * TP/SL price -> pnl
+ */
+declare function priceToPnl(inputs: {
+    qty: number;
+    price: number;
+    entryPrice: number;
+    orderSide: OrderSide;
+    orderType: AlgoOrderType;
+}, options?: {
+    symbol?: API.SymbolExt;
+}): number;
+
+type index_ValueOf<T> = ValueOf<T>;
+declare const index_cleanStringStyle: typeof cleanStringStyle;
+declare const index_findPositionTPSLFromOrders: typeof findPositionTPSLFromOrders;
+declare const index_findTPSLFromOrder: typeof findTPSLFromOrder;
+declare const index_findTPSLFromOrders: typeof findTPSLFromOrders;
+declare const index_formatNumber: typeof formatNumber;
+declare const index_getPositionBySymbol: typeof getPositionBySymbol;
+declare const index_priceToPnl: typeof priceToPnl;
+declare namespace index {
+  export { type index_ValueOf as ValueOf, index_cleanStringStyle as cleanStringStyle, index_findPositionTPSLFromOrders as findPositionTPSLFromOrders, index_findTPSLFromOrder as findTPSLFromOrder, index_findTPSLFromOrders as findTPSLFromOrders, index_formatNumber as formatNumber, index_getPositionBySymbol as getPositionBySymbol, index_priceToPnl as priceToPnl };
+}
+
+declare const useCommission: (options?: {
+    size?: number;
+}) => any[];
+
+declare namespace RefferalAPI {
+    interface ReferralInfo {
+        referrer_info: Referrer;
+        referee_info: Referee;
+    }
+    type ReferralCode = {
+        "code": string;
+        "max_rebate_rate": number;
+        "referee_rebate_rate": number;
+        "referrer_rebate_rate": number;
+        "total_invites": number;
+        "total_traded": number;
+    };
+    type Referrer = {
+        "total_invites": number;
+        "total_traded": number;
+        "total_referee_volume": number;
+        "total_referee_fee": number;
+        "referral_codes": ReferralCode[];
+        "total_referrer_rebate": number;
+        "1d_invites": number;
+        "7d_invites": number;
+        "30d_invites": number;
+        "1d_traded": number;
+        "7d_traded": number;
+        "30d_traded": number;
+        "1d_referee_volume": number;
+        "7d_referee_volume": number;
+        "30d_referee_volume": number;
+        "1d_referee_fee": number;
+        "7d_referee_fee": number;
+        "30d_referee_fee": number;
+        "1d_referrer_rebate": number;
+        "7d_referrer_rebate": number;
+        "30d_referrer_rebate": number;
+    };
+    type Referee = {
+        "referer_code"?: string;
+        "referee_rebate_rate"?: number;
+        "1d_referee_rebate": number;
+        "7d_referee_rebate": number;
+        "30d_referee_rebate": number;
+        "total_referee_rebate": number;
+    };
+    type RefereeInfoItem = {
+        "account_id": string;
+        "code_binding_time": number;
+        "fee": number;
+        "referral_code": string;
+        "referral_rebate": number;
+        "register_time": number;
+        "trade_status": string;
+        "user_address": string;
+        "volume": number;
+    };
+    type UserVolStats = {
+        "perp_volume_last_30_days": number;
+        "perp_volume_last_7_days": number;
+        "perp_volume_ltd": number;
+        "perp_volume_ytd": number;
+    };
+    type Distribution = {
+        "amount": number;
+        "created_time": number;
+        "id": number;
+        "status": string;
+        "token": string;
+        "type": string;
+        "updated_time": number;
+    };
+    type ReferralRebateSummary = {
+        "referral_rebate": number;
+        "volume": number;
+        "fee": number;
+        "date": string;
+    };
+    type RefereeRebateSummary = {
+        "referee_rebate": number;
+        "fee": number;
+        "date": string;
+    };
+    type DayliVolume = {
+        date: string;
+        perp_volume: number;
+    };
+}
+
+declare const useDaily: (options?: {
+    startDate?: Date;
+    endDate?: Date;
+}) => {
+    data?: RefferalAPI.DayliVolume[] | undefined;
+    mutate: any;
+};
+
+type Params$4 = {
+    size?: number;
+    startDate?: string;
+    endDate?: string;
+    initialSize?: number;
+};
+declare const useDistribution: (params: Params$4) => any;
+
+type Params$3 = {
+    size?: number;
+    startDate?: string;
+    endDate?: string;
+    initialSize?: number;
+    page?: number;
+};
+declare const useReferralRebateSummary: (params: Params$3) => readonly [RefferalAPI.ReferralRebateSummary[] | null, {
+    readonly total: number;
+    readonly isLoading: boolean;
+    readonly refresh: swr__internal.KeyedMutator<any[]>;
+    readonly loadMore: () => void;
+    readonly meta: {
+        total: number;
+        records_per_page: number;
+        current_page: number;
+    } | undefined;
+}];
+
+type Params$2 = {
+    size?: number;
+    startDate?: string;
+    endDate?: string;
+    initialSize?: number;
+};
+declare const useRefereeHistory: (params: Params$2) => any[];
+
+type Params$1 = {
+    size?: number;
+    /**
+     * @deprecated
+     * YYYY-MM-dd */
+    startDate?: string;
+    /**
+     * @deprecated
+     * YYYY-MM-dd */
+    endDate?: string;
+    /** default is 1 */
+    initialSize?: number;
+    sort?: "ascending_code_binding_time" | "descending_code_binding_time" | "ascending_referral_rebate" | "descending_referral_rebate" | "ascending_volume" | "descending_volume";
+    page?: number;
+};
+declare const useRefereeInfo: (params: Params$1) => readonly [RefferalAPI.RefereeInfoItem[] | null, {
+    readonly total: number;
+    readonly isLoading: boolean;
+    readonly refresh: swr__internal.KeyedMutator<any[]>;
+    readonly loadMore: () => void;
+    readonly meta: {
+        total: number;
+        records_per_page: number;
+        current_page: number;
+    } | undefined;
+}];
+
+type Params = {
+    startDate?: Date;
+    endDate?: Date;
+};
+declare const useRefereeRebateSummary: (params: Params) => {
+    data?: RefferalAPI.RefereeRebateSummary[] | undefined;
+    mutate: any;
+    isLoading: boolean;
+};
+
+type CheckReferralCodeReturns = {
+    isExist?: boolean;
+    error: any;
+    isLoading: boolean;
+};
+declare const useCheckReferralCode: (code?: string) => CheckReferralCodeReturns;
+
+declare const useGetReferralCode: (accountId?: string) => {
+    referral_code?: string | undefined;
+    error: any;
+    isLoading: boolean;
+};
+
+declare const useReferralInfo: () => {
+    data?: RefferalAPI.ReferralInfo | undefined;
+    isTrader?: boolean | undefined;
+    isAffiliate?: boolean | undefined;
+    error: any;
+    isLoading: boolean;
+    getFirstRefCode: () => RefferalAPI.ReferralCode | undefined;
+};
+
+declare enum TWType {
+    normal = "normal",
+    mm = "mm"
+}
+
+type EpochInfoItem = {
+    epoch_id: number;
+    start_time: number;
+    end_time: number;
+    epoch_token: string;
+    max_reward_amount: number;
+};
+type EpochInfoType = [
+    data: EpochInfoItem[] | undefined,
+    {
+        isLoading: boolean;
+        curEpochInfo: EpochInfoItem | undefined;
+        isUnstart: boolean;
+        refresh: () => void;
+    }
+];
+declare const useEpochInfo: (type: TWType) => EpochInfoType;
+
+type Brokers = {
+    [key: string]: string;
+};
+declare const useAllBrokers: () => readonly [Brokers | undefined];
+
+type CurrentEpochEstimateRow = {
+    broker_id: string;
+    est_r_account: number;
+    broker_name: string;
+};
+type CurrentEpochEstimate = {
+    est_r_wallet: string;
+    est_stake_boost?: number;
+    est_avg_stake?: number;
+    est_trading_volume: number;
+    rows: CurrentEpochEstimateRow[];
+};
+declare const useCurEpochEstimate: (type: TWType) => readonly [CurrentEpochEstimate | undefined];
+
+type AccountRewardsHistoryRow = {
+    broker_id: string;
+    wallet_epoch_avg_staked?: number;
+    trader_score_major?: number;
+    trader_score_alts?: number;
+    epoch_token?: string;
+    reward_status?: string;
+    r_major?: number;
+    r_alts?: number;
+    r_account?: number;
+    broker_name?: string;
+};
+type AccountRewardsHistory = {
+    epoch_id: number;
+    broker: AccountRewardsHistoryRow[];
+};
+declare const useAccountRewardsHistory: (address?: string) => {
+    data: AccountRewardsHistory[] | undefined;
+};
+
+declare enum DistributionId {
+    order = 0,
+    esORder = 1,
+    mmOrder = 2,
+    mmEsOrder = 3
+}
+declare const useGetClaimed: (id: DistributionId) => [number | undefined, {
+    refresh: () => void;
+}];
+
+type WalletRewardsItem = {
+    epoch_id: number;
+    wallet_epoch_avg_staked: number;
+    epoch_token: string;
+    max_reward_amount: number;
+    reward_status: string;
+    r_wallet: number;
+};
+type WalletRewards = {
+    wallet_lifetime_trading_rewards_order: string;
+    wallet_lifetime_trading_rewards_escrow: string;
+    rows: WalletRewardsItem[];
+};
+type WalletRewardsHisotryReturns = [
+    WalletRewards | undefined,
+    {
+        refresh: () => void;
+        error?: any;
+    }
+];
+declare const useWalletRewardsHistory: (type: TWType) => WalletRewardsHisotryReturns;
+
+declare enum ENVType {
+    prod = "prod",
+    staging = "staging",
+    qa = "qa",
+    dev = "dev"
+}
+declare const useGetEnv: () => ENVType;
+
+type APIKeyItem = {
+    orderly_key: string;
+    key_status: string;
+    ip_restriction_list: string[];
+    ip_restricion_status: string;
+    expiration: number;
+    tag?: any;
+    scope?: string;
+};
+declare enum ScopeType {
+    trade = "trade",
+    trading = "trading",
+    tradeAndTrading = "trade,trading"
+}
+declare const useApiKeyManager: (queryParams?: {
+    keyInfo?: {
+        page?: number;
+        size?: number;
+        keyStatus?: string;
+    };
+}) => readonly [APIKeyItem[] | undefined, {
+    readonly refresh: swr__internal.KeyedMutator<APIKeyItem[]>;
+    readonly error: any;
+    readonly isLoading: boolean;
+    readonly generateOrderlyKey: (scope?: ScopeType) => Promise<{
+        key: string;
+        secretKey: string;
+    }>;
+    readonly setIPRestriction: (orderly_key: string, ip_restriction_list: string) => Promise<any>;
+    readonly removeOrderkyKey: (orderly_key: string) => Promise<any>;
+    readonly resetOrderlyKeyIPRestriction: (orderlyKey: string, mode: "ALLOW_ALL_IPS" | "DISALLOW_ALL_IPS") => Promise<any>;
+}];
+
+export { type APIKeyItem, type AccountRewardsHistory, type AccountRewardsHistoryRow, AssetHistoryStatusEnum, type Brokers, type Chain, type Chains, type CheckReferralCodeReturns, type CollateralOutputs, type ComputedAlgoOrder, type ConfigProviderProps, type ConnectedChain, type CurrentEpochEstimate, DefaultLayoutConfig, DistributionId, type DrawOptions, ENVType, type EpochInfoItem, type EpochInfoType, type Favorite, type FavoriteTab$1 as FavoriteTab, MarketsStorageKey, MarketsType$1 as MarketsType, type OrderBookItem, type OrderParams, type OrderbookData, type OrderbookOptions, type OrderlyConfigContextState, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, type PosterLayoutConfig, type Recent$1 as Recent, RefferalAPI, ScopeType, StatusContext, type StatusContextState, StatusProvider, type SymbolInfo, TWType, type UseChainsOptions, type UseChainsReturnObject, type UseOrderEntryMetaState, WalletConnectorContext, type WalletRewards, type WalletRewardsHisotryReturns, type WalletRewardsItem, type WalletState, WsNetworkStatus, type chainFilter, type chainFilterFunc, checkNotional, cleanStringStyle, type filteredChains$1 as filteredChains, parseJSON, useAccount, useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAssetsHistory, useBoolean, useChain, useChains, useCheckReferralCode, useCollateral, useCommission, useConfig, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEventEmitter, useFundingFeeHistory, useFundingRate, useFundingRates, useGetClaimed, useGetEnv, useGetReferralCode, useHoldingStream, useIndexPrice, useKeyStore, useLazyQuery, useLeverage, useLocalStorage, useMaintenanceStatus, useMarginRatio, useMarkPrice, useMarkPricesStream, useMarketList, useMarketTradeStream, useMarkets, useMarketsStream, useMaxQty, useMediaQuery, useMutation, useOrderEntry, useOrderStream, useOrderbookStream, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useSessionStorage, useSettleSubscription, useSimpleDI, useStatisticsDaily, useSymbolLeverage, useSymbolPriceRange, useSymbolsInfo, useTPSLOrder, useTickerStream, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWithdraw, useWsStatus, index as utils, _default as version };