@kodiak-finance/orderly-hooks 2.7.4

package/dist/index.d.ts

@@ -0,0 +1,2427 @@
+import * as swr from 'swr';
+import { SWRConfiguration, SWRHook, SWRResponse } from 'swr';
+export { swr };
+export { KeyedMutator, Middleware, SWRConfiguration, SWRHook, SWRResponse, unstable_serialize, default as useSWR, useSWRConfig } from 'swr';
+import * as swr_mutation from 'swr/mutation';
+import { SWRMutationConfiguration, SWRMutationResponse } from 'swr/mutation';
+import * as swr_infinite from 'swr/infinite';
+import { SWRInfiniteKeyLoader, SWRInfiniteConfiguration } from 'swr/infinite';
+import * as react from 'react';
+import react__default, { PropsWithChildren, FC, ReactNode } from 'react';
+import * as _kodiak_finance_orderly_types from '@kodiak-finance/orderly-types';
+import { NetworkId, TrackerEventName, API, Chain as Chain$1, OrderlyOrder, ChainNamespace, WSMessage, OrderType, OrderStatus, OrderSide, AlgoOrderRootType, OrderEntity, PositionType, AlgoOrderEntity, AssetHistoryStatusEnum, AlgoOrderType, RequireKeys } from '@kodiak-finance/orderly-types';
+import * as _kodiak_finance_orderly_core from '@kodiak-finance/orderly-core';
+import { AccountState, Account, EventEmitter, ConfigStore, ConfigKey, SimpleDI, OrderlyKeyStore, WalletAdapter, IContract, DefaultConfigStore } from '@kodiak-finance/orderly-core';
+export { SubAccount, WalletAdapter } from '@kodiak-finance/orderly-core';
+import * as lodash from 'lodash';
+import * as amplitude from '@amplitude/analytics-browser';
+export { default as useConstant } from 'use-constant';
+import { WS } from '@kodiak-finance/orderly-net';
+import { EIP1193Provider } from '@web3-onboard/common';
+import { SolanaWalletProvider } from '@kodiak-finance/orderly-default-solana-adapter';
+import * as swr_subscription from 'swr/subscription';
+import * as _kodiak_finance_orderly_utils from '@kodiak-finance/orderly-utils';
+import { Decimal } from '@kodiak-finance/orderly-utils';
+export * from 'use-debounce';
+import * as immer from 'immer';
+import * as zustand from 'zustand';
+
+declare global {
+    interface Window {
+        __ORDERLY_VERSION__?: {
+            [key: string]: string;
+        };
+    }
+}
+declare const _default: "2.7.4";
+
+declare const fetcher: (url: string, init: RequestInit | undefined, queryOptions: useQueryOptions<any>) => Promise<any>;
+type useQueryOptions<T> = SWRConfiguration & {
+    formatter?: (data: any) => T;
+};
+declare const noCacheConfig: SWRConfiguration;
+
+/**
+ * useQuery
+ * @description for public api
+ * @param query
+ * @param options
+ */
+declare const useQuery: <T>(query: Parameters<SWRHook>[0], options?: useQueryOptions<T>) => SWRResponse<T>;
+
+/**
+ * useQuery
+ * @description for public api
+ * @param query
+ * @param options
+ */
+declare const useLazyQuery: <T, R = any>(query: Parameters<SWRHook>[0], options?: SWRMutationConfiguration<any, any> & {
+    formatter?: (data: any) => R;
+    init?: RequestInit;
+}) => SWRMutationResponse;
+
+type HTTP_METHOD$1 = "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>(
+/**
+ * The URL to send the request to. If the URL does not start with "http",
+ * it will be prefixed with the API base URL.
+ */
+url: string, 
+/**
+ * The HTTP method to use for the request. Defaults to "POST".
+ */
+method?: HTTP_METHOD$1, 
+/**
+ * The configuration object for the mutation.
+ * @see [useSWRMutation](https://swr.vercel.app/docs/mutation#api)
+ *
+ * @link https://swr.vercel.app/docs/mutation#api
+ */
+options?: SWRMutationConfiguration<T, E>) => readonly [(this: unknown, data: Record<string, any> | null, params?: Record<string, any> | undefined, 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: Parameters<SWRHook>[0], options?: useQueryOptions<T>) => SWRResponse<T>;
+
+declare const usePrivateInfiniteQuery: <T>(getKey: SWRInfiniteKeyLoader | null, options?: SWRInfiniteConfiguration & {
+    formatter?: (data: any) => any;
+}) => swr_infinite.SWRInfiniteResponse<T, any>;
+
+declare const useInfiniteQuery: <T>(getKey: SWRInfiniteKeyLoader, options?: SWRInfiniteConfiguration & {
+    formatter?: (data: any) => any;
+}) => swr_infinite.SWRInfiniteResponse<T, any>;
+
+declare const useBoolean: (initialValue?: boolean) => [boolean, {
+    setTrue: () => void;
+    setFalse: () => void;
+    toggle: () => void;
+}];
+
+type NotFunction<T> = T extends (...args: any[]) => any ? never : T;
+declare const useUpdatedRef: <T>(val: NotFunction<T>) => react.MutableRefObject<T>;
+
+type noop = (this: any, ...args: any[]) => any;
+type PickFunction<T extends noop> = (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+declare const useMemoizedFn: <T extends noop>(fn?: T) => PickFunction<T>;
+
+interface AudioPlayerOptions {
+    volume?: number;
+    loop?: boolean;
+    autoPlay?: boolean;
+}
+declare const useAudioPlayer: (src: string, options?: AudioPlayerOptions) => readonly [react__default.DetailedReactHTMLElement<{
+    controls: boolean;
+    ref: react__default.MutableRefObject<HTMLAudioElement | null>;
+    autoPlay: boolean | undefined;
+    src: string;
+    style: {
+        display: "none";
+    };
+    onPlay: () => void;
+    onPlaying: () => void;
+    onPause: () => void;
+    onEnded: () => void;
+    onError: () => void;
+}, HTMLAudioElement>, react__default.MutableRefObject<HTMLAudioElement | null>, "error" | "paused" | "idle" | "play" | "playing" | "ended"];
+
+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 AutoGenerateCode = {
+        code: string;
+        requireVolume: number;
+        completedVolume: 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 = {
+        daily_traded_referral: number;
+        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[];
+    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.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.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[];
+    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;
+    error: any;
+    isLoading: boolean;
+};
+
+declare const useReferralInfo: () => {
+    data?: RefferalAPI.ReferralInfo;
+    isTrader?: boolean;
+    isAffiliate?: boolean;
+    error: any;
+    isLoading: boolean;
+    getFirstRefCode: () => RefferalAPI.ReferralCode | undefined;
+};
+
+declare const useAccount: () => {
+    account: _kodiak_finance_orderly_core.Account;
+    state: AccountState;
+    isSubAccount: boolean;
+    isMainAccount: boolean;
+    subAccount: {
+        refresh: () => Promise<Record<string, _kodiak_finance_orderly_types.API.Holding[]>>;
+        create: (description?: string) => Promise<any>;
+        update: (value: {
+            subAccountId: string;
+            description?: string;
+        }) => Promise<any>;
+    };
+    switchAccount: (accountId: string) => Promise<void>;
+    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 parseJSON<T>(value: string | null): T | undefined;
+
+declare function useLocalStorage<T>(key: string, initialValue: T, options?: {
+    parseJSON: typeof parseJSON;
+}): [any, (value: T) => void];
+
+type CurrentChain = {
+    id: number;
+    info?: Chain;
+};
+declare const useNetworkInfo: (networkId: NetworkId) => (chainId: number) => CurrentChain;
+
+declare const useFeeState: () => {
+    readonly takerFee: string;
+    readonly makerFee: string;
+    readonly refereeRebate: number | undefined;
+    readonly effectiveTakerFee: string;
+    readonly effectiveMakerFee: string;
+};
+
+declare const useTrack: () => {
+    track: lodash.DebouncedFunc<(eventName: TrackerEventName, params?: any) => void>;
+    tracking: (eventName: TrackerEventName, params?: any) => void;
+    setTrackUserId: (userId: string) => void;
+    setIdentify: (params: any) => void;
+};
+
+declare enum ENVType$1 {
+    prod = "prod",
+    staging = "staging",
+    qa = "qa",
+    dev = "dev"
+}
+declare class AmplitudeTracker {
+    static instanceName: string;
+    private _userId;
+    private _sdkInfoTag;
+    private _ee;
+    constructor(env: ENVType$1, amplitudeConfig: {
+        amplitudeId: string;
+        serverZone?: amplitude.Types.ServerZoneType;
+    } | undefined, sdkInfo: any);
+    setUserId(userId: string): void;
+    setSdkInfo(sdkInfo: any): void;
+    identify(properties: any): void;
+    track(eventName: TrackerEventName, properties?: any): void;
+    private _bindEvents;
+}
+
+declare const useTrackingInstance: () => AmplitudeTracker;
+
+declare const useWS: () => WS;
+
+declare function useConfig(): ConfigStore;
+declare function useConfig<T = string>(key: ConfigKey, defaultValue?: T): T;
+
+declare const useKeyStore: () => _kodiak_finance_orderly_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;
+    walletAdapters: WalletAdapter[];
+    networkId: NetworkId;
+    /**
+     * @hidden
+     */
+    onlyTestnet?: boolean;
+    filteredChains?: filteredChains$1 | null;
+    customChains?: Chains<undefined, undefined>;
+    chainTransformer?: (params: {
+        chains: API.Chain[];
+        tokenChains: API.Chain[];
+        chainInfos: any[];
+        swapChains: any[];
+        mainnet: boolean;
+    }) => API.Chain[];
+    /** enable swap deposit, default is false */
+    enableSwapDeposit?: boolean;
+    /**
+     * Custom orderbook default tick sizes.
+     */
+    defaultOrderbookTickSizes?: Record<PropertyKey, string>;
+    /**
+     * Custom orderbook default symbol depths.
+     */
+    defaultOrderbookSymbolDepths?: Record<PropertyKey, number[]>;
+    dataAdapter?: {
+        /**
+         * Custom `/v1/public/futures` response data.
+         */
+        symbolList?: (originalVal: API.MarketInfoExt[]) => any[];
+        /**
+         * custom `/v2/public/announcement` response data
+         */
+        announcementList?: (data: any[] | ReadonlyArray<any>) => any[];
+    };
+    notification?: {
+        orderFilled?: {
+            /**
+             * Sound to play when an order is successful.
+             * @default undefined
+             */
+            media?: string;
+            /**
+             * Whether to open the notification by default.
+             * @default false
+             */
+            defaultOpen?: boolean;
+        };
+    };
+    amplitudeConfig?: {
+        amplitudeId: string;
+        serverZone?: "EU" | "US";
+    };
+    orderMetadata?: OrderMetadataConfig;
+}
+type OrderMetadata = {
+    order_tag?: string;
+    client_order_id?: string;
+};
+type OrderMetadataConfig = OrderMetadata | ((order: Partial<OrderlyOrder>) => OrderMetadata);
+declare const OrderlyContext: react.Context<OrderlyConfigContextState>;
+declare const useOrderlyContext: () => OrderlyConfigContextState;
+declare const OrderlyProvider: react.Provider<OrderlyConfigContextState>;
+
+declare const StatusProvider: React.FC<PropsWithChildren>;
+
+declare enum WsNetworkStatus {
+    Connected = "connected",
+    Unstable = "unstable",
+    Disconnected = "disconnected"
+}
+declare function useWsStatus(): WsNetworkStatus;
+
+type filteredChains = {
+    mainnet?: Chain$1[];
+    testnet?: Chain$1[];
+};
+type filterChainsFunc = (config: ConfigStore) => filteredChains;
+type BaseConfigProviderProps = {
+    keyStore?: OrderlyKeyStore;
+    contracts?: IContract;
+    walletAdapters?: WalletAdapter[];
+    chainFilter?: filteredChains | filterChainsFunc;
+    /**
+     * Custom orderbook default tick sizes.
+     */
+    orderbookDefaultTickSizes?: Record<string, string>;
+    /**
+     * Custom orderbook default symbol depths.
+     */
+    orderbookDefaultSymbolDepths?: Record<PropertyKey, number[]>;
+} & Pick<OrderlyConfigContextState, "enableSwapDeposit" | "customChains" | "chainTransformer" | "dataAdapter" | "notification" | "amplitudeConfig" | "orderMetadata">;
+type ExclusiveConfigProviderProps = {
+    brokerId: string;
+    brokerName?: string;
+    networkId: NetworkId;
+    configStore?: never;
+} | {
+    brokerId?: never;
+    brokerName?: never;
+    networkId?: never;
+    configStore: ConfigStore;
+};
+type ConfigProviderProps = BaseConfigProviderProps & ExclusiveConfigProviderProps;
+declare const OrderlyConfigProvider: FC<PropsWithChildren<ConfigProviderProps>>;
+
+declare class ExtendedConfigStore extends DefaultConfigStore {
+    constructor(init: Partial<Record<ConfigKey, any>>);
+    get<T>(key: ConfigKey): T;
+    set<T>(key: ConfigKey, value: T): void;
+}
+
+type ConnectedChain = {
+    id: number | string;
+    namespace: ChainNamespace;
+};
+type WalletAccount = {
+    address: string;
+};
+interface WalletState {
+    label: string;
+    icon: string;
+    provider: EIP1193Provider | SolanaWalletProvider;
+    accounts: WalletAccount[];
+    chains: ConnectedChain[];
+    instance?: unknown;
+    additionalInfo?: Record<string, any>;
+}
+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 | null;
+    connectedChain: ConnectedChain | null;
+    settingChain: boolean;
+    namespace: ChainNamespace | null;
+}
+declare const WalletConnectorContext: react.Context<WalletConnectorContextState>;
+declare const useWalletConnector: () => WalletConnectorContextState;
+
+type OrderBookItem = number[];
+type OrderbookData = {
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+};
+declare const getPriceKey: (rawPrice: number, depth: number, isAsks: boolean) => number;
+/**
+ * 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;
+};
+declare const ORDERLY_ORDERBOOK_DEPTH_KEY = "orderly_orderbook_depth_key";
+/**
+ * @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: (val: number) => void;
+    depth: number;
+    allDepths: number[];
+    isLoading: boolean;
+    onItemClick: (item: OrderBookItem) => void;
+    asks?: undefined;
+    bids?: undefined;
+    markPrice?: undefined;
+    middlePrice?: undefined;
+})[];
+
+/**
+ * Type alias for the return type of useSymbolsInfo hook
+ */
+type SymbolsInfo = ReturnType<typeof useSymbolsInfo>;
+/**
+ * A hook that provides access to symbol information.
+ *
+ * @returns A getter object that provides access to symbol information.
+ * The getter allows accessing symbol data either by symbol name directly,
+ * or through a two-level access pattern (symbol and property).
+ *
+ * @example
+ * ```typescript
+ * const symbolsInfo = useSymbolsInfo();
+ *
+ * // Get all info for a symbol
+ * const ethInfo = symbolsInfo["PERP_ETH_USDC"]();
+ *
+ * // Get specific property for a symbol
+ * const baseDP = symbolsInfo["PERP_ETH_USDC"]('base_dp');
+ *
+ * // Get specific property for a symbol with default value
+ * const quoteDP = symbolsInfo["PERP_ETH_USDC"]('quote_dp', 2);
+ * ```
+ */
+declare const useSymbolsInfo: () => Record<string, <Key extends keyof _kodiak_finance_orderly_types.API.SymbolExt>(key: Key, defaultValue?: _kodiak_finance_orderly_types.API.SymbolExt[Key] | undefined) => _kodiak_finance_orderly_types.API.SymbolExt[Key]> & Record<string, () => _kodiak_finance_orderly_types.API.SymbolExt> & {
+    isNil: boolean;
+};
+declare const useSymbolsInfoStore: () => Record<string, _kodiak_finance_orderly_types.API.SymbolExt> | undefined;
+
+declare const useSymbolInfo: (symbol?: string) => ((<Key extends keyof _kodiak_finance_orderly_types.API.SymbolExt>(key: Key, defaultValue?: _kodiak_finance_orderly_types.API.SymbolExt[Key] | undefined) => _kodiak_finance_orderly_types.API.SymbolExt[Key]) & (() => _kodiak_finance_orderly_types.API.SymbolExt)) | null;
+
+declare const useAccountInfo: () => swr.SWRResponse<API.AccountInfo, any, any>;
+
+declare const useMarketsStream: () => {
+    data: WSMessage.Ticker[] | null;
+};
+
+declare enum MarketsType$1 {
+    FAVORITES = 0,
+    RECENT = 1,
+    ALL = 2,
+    NEW_LISTING = 3
+}
+interface FavoriteTab$1 {
+    name: string;
+    id: number;
+}
+interface Favorite$1 {
+    name: string;
+    tabs: FavoriteTab$1[];
+}
+interface Recent$1 {
+    name: string;
+}
+interface TabSort$1 {
+    sortKey: string;
+    sortOrder: string;
+}
+/** @deprecated use useMarkets instead */
+declare const useMarket: (type: MarketsType$1) => readonly [any[], {
+    readonly favoriteTabs: {
+        name: string;
+        id: number;
+    }[];
+    readonly favorites: Favorite$1[];
+    readonly recent: Recent$1[];
+    readonly tabSort: Record<string, TabSort$1>;
+    readonly addToHistory: (symbol: API.MarketInfoExt) => void;
+    readonly updateFavorites: (favorites: Favorite$1[]) => 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,
+    NEW_LISTING = 3
+}
+interface FavoriteTab {
+    name: string;
+    id: number;
+}
+interface Favorite {
+    name: string;
+    tabs: FavoriteTab[];
+}
+interface Recent {
+    name: string;
+}
+interface NewListing {
+    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;
+};
+type MarketsStore = ReturnType<typeof useMarketsStore>;
+declare const MarketsStorageKey = "orderly_markets";
+declare const useMarketsStore: () => {
+    favoriteTabs: FavoriteTab[];
+    favorites: {
+        tabs: FavoriteTab[];
+        name: string;
+    }[];
+    recent: Recent[];
+    newListing: NewListing[];
+    tabSort: TabSort;
+    selectedFavoriteTab: FavoriteTab;
+    updateFavorites: react.Dispatch<react.SetStateAction<{
+        tabs: FavoriteTab[];
+        name: string;
+    }[]>>;
+    updateFavoriteTabs: (tab: FavoriteTab | FavoriteTab[], operator?: {
+        add?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    }) => void;
+    updateSymbolFavoriteState: (symbol: API.MarketInfoExt, tab: FavoriteTab | FavoriteTab[], remove?: boolean) => void;
+    pinToTop: (symbol: API.MarketInfoExt) => void;
+    addToHistory: (symbol: API.MarketInfoExt) => void;
+    updateSelectedFavoriteTab: (tab: FavoriteTab) => void;
+    updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
+};
+/**
+ * Hook for accessing filtered market data based on type
+ * @param type - Type of markets to filter (defaults to ALL)
+ * @returns Tuple containing filtered markets array and markets store
+ */
+declare const useMarkets: (type?: MarketsType) => [MarketsItem[], MarketsStore];
+
+declare const useMarkPricesStream: () => {
+    data: Record<string, number>;
+};
+
+declare const useIndexPricesStream: () => {
+    data: Record<string, number>;
+    getIndexPrice: (this: unknown, token: string) => number;
+};
+
+declare const useMarkPrice: (symbol: string) => {
+    data: number;
+};
+
+declare const useIndexPrice: (symbol: string) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+/**
+ * A hook for managing leverage in trading.
+ *
+ * @remarks
+ * This hook provides functionality to get and update the user's leverage settings.
+ *
+ * It fetches the current leverage from client info and available leverage options from config.
+ *
+ * @returns A tuple containing:
+ * - The current maximum leverage value
+ * - An object with:
+ *   - `update`: Function to update leverage
+ *   - `isMutating`: Boolean indicating if an update is in progress
+ *   - `config`: Array of available leverage options (e.g. [1, 2, 3, 4, 5, 10, 15, 20])
+ *
+ * @example
+ * ```typescript
+ * const [maxLeverage, { update, isMutating, config }] = useLeverage();
+ *
+ * // Get current max leverage
+ * console.log(maxLeverage);
+ *
+ * // Update leverage
+ * update({ leverage: 5 });
+ *
+ * // Available leverage options
+ * console.log(config); // e.g., [1, 2, 3, 4, 5, 10, 15, 20]
+ * ```
+ */
+declare const useLeverage: () => {
+    readonly update: (data: {
+        leverage: number;
+    }) => Promise<{
+        max_leverage: string | number;
+    } | undefined>;
+    readonly isLoading: boolean;
+    readonly leverageLevers: number[];
+    readonly curLeverage: number;
+    readonly maxLeverage: number;
+};
+
+declare const useOdosQuote: () => readonly [(this: unknown, data: Record<string, any> | null, params?: Record<string, any> | undefined, options?: swr_mutation.SWRMutationConfiguration<unknown, unknown> | undefined) => Promise<any>, {
+    readonly data: any;
+    readonly error: unknown;
+    readonly reset: () => void;
+    readonly isMutating: boolean;
+}];
+
+interface LTVOptions {
+    input?: number;
+    token?: string;
+}
+declare const useComputedLTV: (options?: LTVOptions) => number;
+
+declare const useTickerStream: (symbol: string) => API.MarketInfo & {
+    change?: number;
+    "24h_change"?: number;
+};
+
+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 useFundingDetails: (symbol: string) => swr.SWRResponse<API.FundingDetails, any, any>;
+
+type FundingRates = ReturnType<typeof useFundingRates>;
+declare const useFundingRates: () => Record<string, <Key extends keyof API.FundingRate>(key: Key, defaultValue?: API.FundingRate[Key] | undefined) => API.FundingRate[Key]> & Record<string, () => API.FundingRate> & {
+    isNil: boolean;
+};
+declare const useFundingRatesStore: () => Record<string, API.FundingRate> | undefined;
+
+type PeriodKey = "1d" | "3d" | "7d" | "14d" | "30d" | "90d";
+declare const useFundingRateHistory: () => {
+    data: readonly any[];
+    isLoading: boolean;
+    getPositiveRates: (data: ReadonlyArray<API.FundingHistory> | API.FundingHistory[], period: PeriodKey) => Record<string, number>;
+};
+
+type PriceMode = "markPrice" | "lastPrice";
+declare const usePositionStream: (
+/**
+ * If symbol is passed, only the position of that symbol will be returned.
+ */
+symbol?: string, options?: SWRConfiguration & {
+    calcMode?: PriceMode;
+    /**
+     * If true, the pending order will be included in the result.
+     */
+    includedPendingOrder?: boolean;
+}) => readonly [{
+    readonly rows: API.PositionTPSLExt[];
+    readonly aggregated: Omit<API.PositionsTPSLExt, "rows">;
+    readonly totalCollateral: _kodiak_finance_orderly_utils.Decimal;
+    readonly totalValue: _kodiak_finance_orderly_utils.Decimal | null;
+    readonly totalUnrealizedROI: number;
+}, Record<"unsettledPnL" | "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" | "unrealPnL" | "total_unreal_pnl" | "total_unreal_pnl_index" | "total_unsettled_pnl" | "notional" | "unrealPnlROI" | "unrealPnlROI_index", <Key extends "unsettledPnL" | "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" | "unrealPnL" | "total_unreal_pnl" | "total_unreal_pnl_index" | "total_unsettled_pnl" | "notional" | "unrealPnlROI" | "unrealPnlROI_index">(defaultValue?: Omit<API.PositionInfo, "rows">[Key] | undefined) => Omit<API.PositionInfo, "rows">[Key]> & {
+    isNil: boolean;
+}, {
+    /**
+     * @deprecated use `isLoading` instead
+     */
+    readonly loading: boolean;
+    readonly isLoading: boolean;
+}];
+
+declare const findTPSLFromOrder: (order: API.AlgoOrder) => {
+    tp_trigger_price?: number;
+    sl_trigger_price?: number;
+};
+declare const findTPSLOrderPriceFromOrder: (order: API.AlgoOrder) => {
+    tp_order_price: OrderType | number | undefined;
+    sl_order_price: OrderType | number | undefined;
+};
+declare const findPositionTPSLFromOrders: (orders: API.AlgoOrder[], symbol: string) => {
+    fullPositionOrder?: API.AlgoOrder;
+    partialPositionOrders?: API.AlgoOrder[];
+};
+
+type CombineOrderType = AlgoOrderRootType | "ALL";
+declare const useOrderStream: (
+/**
+ * Orders query params
+ */
+params: {
+    symbol?: string;
+    status?: OrderStatus;
+    page?: number;
+    size?: number;
+    side?: OrderSide;
+    sourceTypeAll?: boolean;
+    /**
+     * 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: () => void;
+    readonly loadMore: () => void;
+    readonly cancelAllOrders: () => Promise<[any, 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 cancelPostionOrdersByTypes: (symbol: string, types: AlgoOrderRootType[]) => 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;
+};
+
+/**
+ * The return type of useCollateral hook, containing account collateral information
+ */
+type CollateralOutputs = {
+    /**
+     * Total collateral value in the account
+     *
+     * This includes all assets that can be used as margin
+     */
+    totalCollateral: number;
+    /**
+     * Available collateral that can be used for new positions
+     *
+     * Calculated as: totalCollateral - margin requirements
+     */
+    freeCollateral: number;
+    /**
+     * Total portfolio value including all positions and collateral
+     *
+     * Can be null if data is not available
+     */
+    totalValue: number | null;
+    /**
+     * Current available balance that can be withdrawn
+     *
+     * Excludes locked collateral and pending settlements
+     */
+    availableBalance: number;
+    /**
+     * Unrealized profit and loss across all open positions
+     *
+     * Positive value indicates profit, negative indicates loss
+     */
+    unsettledPnL: number;
+    /**
+     * List of holdings in the account
+     *
+     * Each holding represents a specific token and its quantity
+     */
+    holding?: API.Holding[];
+    /**
+     * Detailed account information and settings
+     *
+     * Contains account configuration, limits and risk parameters
+     */
+    accountInfo?: API.AccountInfo;
+};
+/**
+ *  Hook to get and calculate collateral-related data for an account
+ * @example
+ * ```typescript
+ * const {
+ *  totalCollateral,
+ *  freeCollateral,
+ *  totalValue,
+ *  availableBalance,
+ *  unsettledPnL,
+ *  accountInfo,
+ * } = useCollateral({ dp: 4 });
+ * ```
+ */
+declare const useCollateral: (options?: {
+    /**
+     * Decimal precision for numerical values (default: 6)
+     * */
+    dp: number;
+}) => CollateralOutputs;
+
+/**
+ * A hook that calculates the maximum tradeable quantity for a given symbol and side
+ * @returns Maximum tradeable quantity
+ * @example
+ * ```tsx
+ * // Get max buy quantity for BTC
+ * const maxBuyQty = useMaxQty("PERP_BTC_USDC", OrderSide.BUY);
+ *
+ * // Get max sell quantity with reduce only
+ * const maxSellQty = useMaxQty("PERP_BTC_USDC", OrderSide.SELL, true);
+ * ```
+ */
+declare const useMaxQty: (
+/**
+ * Trading pair symbol (e.g. "PERP_BTC_USDC")
+ * */
+symbol: string, 
+/**
+ * Order side ("BUY" or "SELL")
+ * */
+side: OrderSide, 
+/**
+ * Executes buy or sell orders which only reduce a current position.
+ *
+ * If true, only allows orders that reduce current position
+ * */
+reduceOnly?: boolean) => number;
+
+/**
+ * The return type of useMarginRatio hook
+ */
+type MarginRatioReturn = {
+    /**
+     * Current leverage of the account, null if trading is not enabled
+     */
+    currentLeverage: number | null;
+    /**
+     * Current margin ratio of the account
+     */
+    marginRatio: number;
+    /**
+     * Maintenance margin ratio (MMR) of the account, null if user has no positions
+     */
+    mmr: number | null;
+};
+/**
+ * Hook to calculate and monitor account's margin ratio, leverage, and maintenance margin ratio (MMR)
+ * @example
+ * ```typescript
+ * const { marginRatio, currentLeverage, mmr } = useMarginRatio();
+ * ```
+ */
+declare const useMarginRatio: () => MarginRatioReturn;
+
+declare function useStorageChain(): {
+    storageChain: any;
+    setStorageChain: (chainId: number) => void;
+};
+
+/**
+ * @param token @deprecated, use useTokenInfo instead
+ */
+declare const useChain: (token: string) => {
+    chains: API.Chain | null;
+    isLoading: boolean;
+};
+
+declare const useChainInfo: () => swr.SWRResponse<unknown, any, any>;
+
+type UseWithdrawOptions = {
+    srcChainId?: number;
+    token?: string;
+    /** orderly token decimals */
+    decimals?: 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>;
+    maxAmount: number;
+    unsettledPnL: number;
+    availableBalance: number;
+    /** @deprecated use maxAmount instead */
+    availableWithdraw: number;
+};
+
+type DepositOptions = {
+    address?: string;
+    decimals?: number;
+    srcChainId?: number;
+    /** input token */
+    srcToken?: string;
+    /** output token */
+    dstToken?: string;
+    swapEnable?: boolean;
+    crossChainRouteAddress?: string;
+    depositorAddress?: string;
+    /** @deprecated unused, will be removed in the future */
+    networkId?: NetworkId;
+};
+declare const useDeposit: (options: DepositOptions) => {
+    /** 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>;
+    fetchBalance: (address: string, decimals?: number) => Promise<string>;
+    fetchBalances: (tokens: API.TokenInfo[]) => Promise<string[]>;
+    /** set input quantity */
+    setQuantity: react.Dispatch<react.SetStateAction<string>>;
+};
+
+interface ConvertOptions {
+    token?: string;
+}
+declare const useConvert: (options: ConvertOptions) => {
+    maxAmount: number;
+    convert: (inputs: {
+        amount: number;
+        slippage: number;
+    }) => Promise<any>;
+};
+
+type Receiver = {
+    account_id: string;
+    amount: number;
+};
+type TransferOptions = {
+    /** if not provided, use current account id */
+    fromAccountId?: string;
+    token?: string;
+};
+declare const useTransfer: (options?: TransferOptions) => {
+    submitting: boolean;
+    transfer: (token: string, receivers: Receiver | Receiver[]) => Promise<any>;
+    maxAmount: number;
+    unsettledPnL: number;
+    holding: _kodiak_finance_orderly_types.API.Holding[] | undefined;
+};
+
+type InternalTransferInputs = {
+    token: string;
+    amount: string;
+    receiver: string;
+    /** orderly token decimals */
+    decimals: number;
+};
+declare const useInternalTransfer: () => {
+    submitting: boolean;
+    transfer: (inputs: InternalTransferInputs) => Promise<any>;
+};
+
+/**
+ * The max withdrawal amount for the token
+ * if token is not provided, return the max withdrawal amount for USDC
+ */
+declare const useMaxWithdrawal: (token: string) => number;
+
+declare const useHoldingStream: () => {
+    data: API.Holding[] | undefined;
+    usdc: API.Holding | undefined;
+    isLoading: boolean;
+};
+
+declare const useWalletSubscription: (options?: {
+    onMessage?: (data: any) => void;
+}) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useBalanceSubscription: (options?: {
+    onMessage?: (data: any) => void;
+}) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useWalletTopic: (options: {
+    onMessage: (data: any) => void;
+}) => void;
+
+declare const useBalanceTopic: (options: {
+    onMessage: (data: any) => void;
+}) => void;
+
+declare const useSettleSubscription: (options?: {
+    onMessage?: (data: any) => void;
+}) => 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 OrderValidationItem = {
+    type: "required";
+    message: string;
+    value?: never;
+} | {
+    type: "max" | "min";
+    message: string;
+    value: number | string;
+} | {
+    type: "range";
+    message: string;
+    value?: never;
+    min: number | string;
+    max: number | string;
+} | {
+    type: "priceErrorMin" | "priceErrorMax";
+    message: string;
+    value?: never;
+};
+type OrderValidationResult = {
+    [P in keyof OrderlyOrder]?: OrderValidationItem;
+};
+type ValuesDepConfig = {
+    symbol: API.SymbolExt;
+    maxQty: number;
+    markPrice: number;
+    estSlippage?: number | null;
+    /** [ask0, bid0] */
+    askAndBid?: number[];
+};
+interface OrderCreator<T> {
+    create: (values: T, configs: ValuesDepConfig) => T;
+    validate: (values: T, configs: ValuesDepConfig) => Promise<{
+        [P in keyof T]?: OrderValidationItem;
+    }>;
+    get type(): OrderType;
+}
+
+type TPSLComputedData = {
+    /**
+     * 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 ComputedAlgoOrder = Partial<AlgoOrderEntity<AlgoOrderRootType.TP_SL> & TPSLComputedData>;
+type ValidateError = {
+    [P in keyof ComputedAlgoOrder]?: OrderValidationItem;
+};
+/**
+ * @hidden
+ */
+declare const useTaskProfitAndStopLossInternal: (position: Partial<API.PositionTPSLExt> & Pick<API.PositionTPSLExt, "symbol" | "average_open_price" | "position_qty">, options?: {
+    defaultOrder?: API.AlgoOrder;
+    /**
+     * If the order is editing, set to true
+     * if the isEditing is true, the defaultOrder must be provided
+     * Conversely, even if defaultOrder is provided and isEditing is false, a new TPSL order is still created
+     */
+    isEditing?: boolean;
+    tpslEnable?: {
+        tp_enable?: boolean;
+        sl_enable?: boolean;
+    };
+    positionType?: PositionType;
+}) => [
+/**
+ * return the computed & formatted order
+ */
+ComputedAlgoOrder, {
+    /**
+     * Update the take profit and stop loss order, this will merge the new data with the old one
+     */
+    setValue: (key: string, value: number | string | boolean) => void;
+    setValues: (values: Partial<ComputedAlgoOrder>) => void;
+    /**
+     * Submit the TP/SL order
+     */
+    submit: (params?: {
+        accountId?: string;
+    }) => Promise<any>;
+    deleteOrder: (orderId: number, symbol: string) => Promise<any>;
+    errors: ValidateError | null;
+    /**
+     *
+     */
+    validate: () => Promise<AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL | AlgoOrderRootType.TP_SL>>;
+    metaState: {
+        dirty: { [K in keyof OrderlyOrder]?: boolean; };
+        submitted: boolean;
+        validated: boolean;
+        errors: ValidateError | null;
+    };
+    isCreateMutating: boolean;
+    isUpdateMutating: boolean;
+}];
+
+declare const useTPSLOrder: (
+/**
+ * Position that needs to set take profit and stop loss
+ */
+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;
+    tpslEnable?: {
+        tp_enable?: boolean;
+        sl_enable?: boolean;
+    };
+    isEditing?: boolean;
+    positionType?: PositionType;
+}) => ReturnType<typeof useTaskProfitAndStopLossInternal>;
+
+/**
+ * A custom hook that calculates the maximum allowed leverage for a given trading pair symbol.
+ *
+ * The final leverage is determined by taking the minimum value between the account's maximum
+ * leverage and the symbol's maximum leverage.
+ *
+ * @param symbol - Trading pair symbol (e.g. "PERP_BTC_USDC")
+ * @returns The maximum allowed leverage as a number, or "-" if the leverage cannot be determined
+ *
+ * @example
+ * ```typescript
+ * const leverage = useMaxLeverage("PERP_BTC_USDC");
+ * console.log(`Maximum leverage for PERP_BTC_USDC: ${leverage}x`);
+ * ```
+ */
+declare const useMaxLeverage: (symbol: string) => number;
+
+/**
+ * A custom hook that calculates the maximum allowed leverage for a given trading pair symbol.
+ *
+ * The final leverage is determined by taking the minimum value between the account's maximum
+ * leverage and the symbol's maximum leverage.
+ *
+ * @param symbol - Trading pair symbol (e.g. "PERP_BTC_USDC")
+ * @returns The maximum allowed leverage as a number, or "-" if the leverage cannot be determined
+ *
+ * @example
+ * ```typescript
+ * const leverage = useMaxSymbolLeverage("PERP_BTC_USDC");
+ * console.log(`Maximum leverage for PERP_BTC_USDC: ${leverage}x`);
+ * ```
+ */
+declare const useSymbolLeverage: (symbol?: string) => {
+    maxLeverage: number;
+    update: (this: unknown, data: Record<string, any> | null, params?: Record<string, any> | undefined, options?: swr_mutation.SWRMutationConfiguration<unknown, unknown> | undefined) => Promise<any>;
+    isLoading: boolean;
+};
+
+/**
+ * A hook to fetch and subscribe to leverage for a given trading symbol.
+ * It initially fetches the leverage data via a private query and then listens for real-time
+ * updates through a WebSocket subscription to keep the leverage value current.
+ *
+ * @param symbol - The trading symbol (e.g. "PERP_BTC_USDC")
+ * @returns The current leverage value associated with the symbol, or undefined if not available
+ *
+ * @example
+ * ```typescript
+ * const leverage = useLeverageBySymbol("PERP_BTC_USDC");
+ * ```
+ */
+declare const useLeverageBySymbol: (symbol?: string) => number | undefined;
+
+type AssetHistoryOptions = {
+    /** token name you want to search */
+    token?: string;
+    /** DEPOSIT、WITHDRAW, all */
+    side?: string;
+    status?: AssetHistoryStatusEnum;
+    /** start time in milliseconds */
+    startTime?: number;
+    /** end time in milliseconds */
+    endTime?: number;
+    page?: number;
+    pageSize?: number;
+};
+/**
+ * Get asset history, including token deposits/withdrawals.
+ * https://orderly.network/docs/build-on-omnichain/evm-api/restful-api/private/get-asset-history#get-asset-history
+ */
+declare const useAssetsHistory: (options: AssetHistoryOptions, config?: {
+    /**
+     * should update when wallet changed, default is update
+     */
+    shouldUpdateOnWalletChanged?: (data: any) => boolean;
+}) => readonly [readonly any[], {
+    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 [readonly any[], {
+    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;
+}];
+
+interface TransferHistorySearchParams$1 {
+    dataRange?: number[];
+    page: number;
+    size: number;
+    fromId?: string;
+    toId?: string;
+    side: "IN" | "OUT";
+    /**
+     * If True, return only internal transfers between main account and sub-accounts.
+     * If False, return only internal transfers between main account and other main accounts.
+     * If empty, return all transfer history.
+     * @default true
+     */
+    main_sub_only?: boolean;
+}
+declare const useTransferHistory: (parmas: TransferHistorySearchParams$1) => readonly [API.TransferHistoryRow[], {
+    readonly meta: API.RecordsMeta | undefined;
+    readonly isLoading: boolean;
+    readonly mutate: swr.KeyedMutator<API.TransferHistory>;
+}];
+
+interface TransferHistorySearchParams {
+    dataRange?: number[];
+    page: number;
+    size: number;
+}
+declare const useVaultsHistory: (parmas: TransferHistorySearchParams) => (API.StrategyVaultHistoryRow[] | {
+    meta: API.RecordsMeta | undefined;
+    isLoading: boolean;
+    mutate: swr.KeyedMutator<API.StrategyVaultHistory>;
+})[];
+
+/** 0 for nothing,  2 for maintenance */
+declare enum MaintenanceStatus {
+    None = 0,
+    Maintenance = 2
+}
+declare const useMaintenanceStatus: () => {
+    status: number;
+    brokerName: string;
+    startTime: number | undefined;
+    endTime: number | undefined;
+};
+
+declare const useMarkPriceBySymbol: (symbol: string) => number;
+
+type PositionActions = {
+    setPositions: (key: string, positions: API.PositionsTPSLExt) => void;
+    clearAll: () => void;
+    closePosition: (symbol: string) => void;
+};
+declare const usePositionActions: () => PositionActions;
+
+declare const useStorageLedgerAddress: () => {
+    setLedgerAddress: (address: string) => void;
+    ledgerWallet: any;
+};
+
+/**
+ * return all tokens info
+ */
+declare const useTokensInfo: () => API.Chain[];
+/**
+ * return token info by specify token
+ */
+declare const useTokenInfo: (token: string) => API.Chain | undefined;
+
+type Portfolio$1 = {
+    holding?: API.Holding[];
+    totalCollateral: Decimal;
+    freeCollateral: Decimal;
+    totalValue: Decimal | null;
+    availableBalance: number;
+    unsettledPnL: number;
+    totalUnrealizedROI: number;
+};
+declare const usePortfolio: () => Portfolio$1;
+
+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<OrderlyOrder>, 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 "@kodiak-finance/orderly-hooks";
+ * import {OrderSide, OrderType} from '@kodiak-finance/orderly-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$1(order: OrderParams, options?: UseOrderEntryOptions): UseOrderEntryReturn;
+/**
+ * @deprecated
+ */
+declare function useOrderEntry$1(symbol: string, side: OrderSide, reduceOnly: boolean): UseOrderEntryReturn;
+
+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: (
+/**
+ * The options to draw the poster
+ */
+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;
+
+type FullOrderState$1 = OrderlyOrder;
+
+declare const cleanStringStyle: (str: string | number) => string;
+/**
+ * format number
+ * TODO: refactor this
+ */
+declare function formatNumber(qty?: string | number, dp?: number | string): string | undefined;
+declare function calculate(values: Partial<FullOrderState$1>, fieldName: keyof FullOrderState$1, value: any, markPrice: number, config: API.SymbolExt): Partial<FullOrderState$1>;
+
+/**
+ * get the min notional for the order
+ */
+declare function getMinNotional(props: {
+    base_tick?: number;
+    price?: string | number;
+    qty?: string | number;
+    min_notional?: number;
+    quote_dp?: number;
+    base_dp?: number;
+    quote_tick?: number;
+}): string | undefined;
+/**
+ * @deprecated please use getMinNotional instead, it will be removed in next major version
+ */
+declare function checkNotional(props: {
+    base_tick: number;
+    price?: string | number;
+    qty?: string | number;
+    min_notional?: number;
+    quote_dp?: number;
+    base_dp?: number;
+    quote_tick?: number;
+}): string | undefined;
+
+declare function getPositionBySymbol(symbol: string): void;
+
+/**
+ * TP/SL price -> pnl
+ * @price trigger_price
+ * @entryPrice calculate price, maybe markPrice/limitPrice/order.price
+ */
+declare function priceToPnl(inputs: {
+    qty: number;
+    price: number;
+    entryPrice: number;
+    orderSide: OrderSide;
+    orderType: AlgoOrderType;
+}, options?: {
+    symbol?: Pick<API.SymbolExt, "quote_dp">;
+}): number;
+declare function calcTPSL_ROI(inputs: {
+    pnl: number | string;
+    qty: number | string;
+    price: number | string;
+}): string;
+
+declare const index_calcTPSL_ROI: typeof calcTPSL_ROI;
+declare const index_cleanStringStyle: typeof cleanStringStyle;
+declare const index_fetcher: typeof fetcher;
+declare const index_findPositionTPSLFromOrders: typeof findPositionTPSLFromOrders;
+declare const index_findTPSLFromOrder: typeof findTPSLFromOrder;
+declare const index_findTPSLOrderPriceFromOrder: typeof findTPSLOrderPriceFromOrder;
+declare const index_formatNumber: typeof formatNumber;
+declare const index_getPositionBySymbol: typeof getPositionBySymbol;
+declare const index_noCacheConfig: typeof noCacheConfig;
+declare const index_priceToPnl: typeof priceToPnl;
+type index_useQueryOptions<T> = useQueryOptions<T>;
+declare namespace index {
+  export { index_calcTPSL_ROI as calcTPSL_ROI, index_cleanStringStyle as cleanStringStyle, index_fetcher as fetcher, index_findPositionTPSLFromOrders as findPositionTPSLFromOrders, index_findTPSLFromOrder as findTPSLFromOrder, index_findTPSLOrderPriceFromOrder as findTPSLOrderPriceFromOrder, index_formatNumber as formatNumber, index_getPositionBySymbol as getPositionBySymbol, index_noCacheConfig as noCacheConfig, index_priceToPnl as priceToPnl, type index_useQueryOptions as useQueryOptions };
+}
+
+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;
+        isNotStared: boolean;
+        refresh: () => void;
+    }
+];
+declare const useEpochInfo: (type: TWType) => EpochInfoType;
+
+type Brokers = {
+    [key: string]: string;
+};
+/** get all brokers, will be callback a list */
+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;
+    wallet_pending_trading_rewards_order: string;
+    wallet_pending_trading_rewards_escrow: string;
+    rows: WalletRewardsItem[];
+};
+type WalletRewardsHistoryReturns = [
+    WalletRewards | undefined,
+    {
+        refresh: () => void;
+        error?: any;
+    }
+];
+declare const useWalletRewardsHistory: (type: TWType) => WalletRewardsHistoryReturns;
+
+declare enum EpochStatus {
+    active = "Active",
+    paused = "Paused",
+    ended = "Ended"
+}
+type StatusInfo = {
+    epochStatus: EpochStatus;
+    currentEpoch: number | undefined;
+    lastCompletedEpoch: number | undefined;
+};
+declare function useTradingRewardsStatus(isMMRewards: boolean): {
+    statusInfo: StatusInfo | undefined;
+};
+
+declare enum ENVType {
+    prod = "prod",
+    staging = "staging",
+    qa = "qa",
+    dev = "dev"
+}
+/**
+ * env is determined by networkId and env
+ * | networkId | env     | retrurn  |
+ * |-----------|---------|----------|
+ * | mainnet   | noset   | prod     |
+ * | mainnet   | prod    | prod     |
+ * | mainnet   | staging | prod     |
+ * | mainnet   | qa      | prod     |
+ * | mainnet   | dev     | prod     |
+ * | testnet   | noset   | staging  |
+ * | testnet   | prod    | staging  |
+ * | testnet   | staging | staging  |
+ * | testnet   | qa      | qa       |
+ * | testnet   | dev     | dev      |
+ * if env is not set, return staging
+ *
+ * @returns {ENVType}
+ */
+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;
+        key_status?: string;
+    };
+}) => readonly [APIKeyItem[] | undefined, {
+    readonly refresh: swr.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 removeOrderlyKey: (orderly_key: string) => Promise<any>;
+    readonly resetOrderlyKeyIPRestriction: (orderlyKey: string, mode: "ALLOW_ALL_IPS" | "DISALLOW_ALL_IPS") => Promise<any>;
+}];
+
+type FullOrderState = OrderlyOrder;
+type OrderEntryStateEntity = RequireKeys<FullOrderState, "side" | "order_type" | "symbol">;
+type OrderEntryState = {
+    entry: OrderEntryStateEntity;
+    estLeverage: number | null;
+    estLiquidationPrice: number | null;
+    errors: Partial<Record<keyof FullOrderState, string>>;
+};
+type OrderEntryActions = {
+    updateOrder: (order: Partial<FullOrderState>) => void;
+    updateOrderByKey: <K extends keyof FullOrderState>(key: K, value: FullOrderState[K]) => void;
+    restoreOrder: (order?: Partial<FullOrderState>) => void;
+    updateOrderComputed: (data: {
+        estLeverage: number | null;
+        estLiquidationPrice: number | null;
+    }) => void;
+    resetOrder: (order?: Partial<FullOrderState>) => void;
+    hasTP_SL: () => boolean;
+};
+declare const useOrderStore: zustand.UseBoundStore<Omit<zustand.StoreApi<OrderEntryState & {
+    actions: OrderEntryActions;
+}>, "setState"> & {
+    setState(nextStateOrUpdater: (OrderEntryState & {
+        actions: OrderEntryActions;
+    }) | Partial<OrderEntryState & {
+        actions: OrderEntryActions;
+    }> | ((state: immer.WritableDraft<OrderEntryState & {
+        actions: OrderEntryActions;
+    }>) => void), shouldReplace?: boolean | undefined): void;
+}>;
+
+declare const useOrderEntryNextInternal: (symbol: string, options?: {
+    /**
+     * initial order state, default is buy limit order
+     *
+     */
+    initialOrder?: Omit<Partial<FullOrderState>, "symbol">;
+    symbolInfo?: API.SymbolExt;
+}) => {
+    readonly formattedOrder: Required<Pick<OrderlyOrder, "symbol" | "side" | "order_type">> & Partial<Omit<OrderlyOrder, "symbol" | "side" | "order_type">>;
+    readonly setValue: (key: keyof FullOrderState, value: any, additional?: {
+        markPrice: number;
+    }) => Partial<OrderlyOrder> | undefined;
+    readonly setValues: (values: Partial<FullOrderState>, additional?: {
+        markPrice: number;
+    }) => Partial<OrderlyOrder> | undefined;
+    readonly submit: () => void;
+    readonly reset: (order?: Partial<OrderlyOrder>) => void;
+    readonly generateOrder: (creator: OrderCreator<any>, options: {
+        maxQty: number;
+        markPrice: number;
+        estSlippage?: number | null;
+        askAndBid?: number[];
+    }) => any;
+    readonly validate: (order: Partial<OrderlyOrder>, creator: OrderCreator<any>, options: {
+        maxQty: number;
+        markPrice: number;
+        estSlippage?: number | null;
+        askAndBid?: number[];
+    }) => Promise<{
+        [x: string]: OrderValidationItem | undefined;
+    }>;
+    readonly onMarkPriceChange: (markPrice: number, baseOn?: string[]) => void;
+};
+
+type OrderEntryParameters = Parameters<typeof useOrderEntryNextInternal>;
+type Options$1 = Omit<OrderEntryParameters["1"], "symbolInfo">;
+type OrderEntryReturn = {
+    submit: (options?: {
+        resetOnSuccess?: boolean;
+    }) => Promise<{
+        success: boolean;
+        data: Record<string, any>;
+        timestamp: number;
+    }>;
+    reset: () => void;
+    resetErrors: () => void;
+    resetMetaState: () => void;
+    formattedOrder: Partial<FullOrderState>;
+    maxQty: number;
+    /**
+     * The estimated liquidation price.
+     */
+    estLiqPrice: number | null;
+    /**
+     * The estimated leverage after order creation.
+     */
+    estLeverage: number | null;
+    estSlippage: number | null;
+    helper: {
+        /**
+         * @deprecated Use `validate` instead.
+         */
+        validator: () => Promise<OrderValidationResult | null>;
+        /**
+         * Function to validate the order.
+         * @returns {Promise<OrderValidationResult | null>} The validation result.
+         */
+        validate: () => Promise<OrderValidationResult | null>;
+    };
+    freeCollateral: number;
+    /**
+     * set a single value to the order data;
+     * @param key
+     * @param value
+     * @returns
+     */
+    setValue: (key: keyof FullOrderState, value: any, options?: {
+        shouldUpdateLastChangedField?: boolean;
+    }) => void;
+    setValues: (values: Partial<FullOrderState>) => void;
+    symbolInfo: API.SymbolExt;
+    /**
+     * Meta state including validation and submission status.
+     */
+    metaState: {
+        dirty: {
+            [K in keyof OrderlyOrder]?: boolean;
+        };
+        submitted: boolean;
+        validated: boolean;
+        errors: OrderValidationResult | null;
+    };
+    /**
+     * Indicates if a mutation (order creation) is in progress.
+     */
+    isMutating: boolean;
+    markPrice: number | undefined;
+};
+/**
+ * Custom hook for managing order entry in the Orderly application.
+ *
+ * @param {string} symbol - The symbol for which the order is being created. This parameter is required.
+ *
+ * @param {Options} options - Additional options for configuring the order entry.
+ *
+ * @returns {OrderEntryReturn} An object containing various actions and state related to order entry.
+ *
+ * @throws {Error} Throws an error if the symbol is not provided or is not a string.
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   submit,
+ *   formattedOrder, //
+ *   setValue,
+ *   setValues,
+ *   symbolInfo,
+ *   metaState,
+ *   isMutating,
+ *  // maxQty, freeCollateral ... same as v1
+ * } = useOrderEntry('BTC_USDC_PERP', options);
+ *
+ * // update the order type
+ * setValue('order_type', OrderType.LIMIT);
+ * // update the order price
+ * setValue('order_price', '70000');
+ * // update the order quantity
+ * setValue('order_quantity', 1);
+ *
+ * // how to set TP/SL
+ * setValue('tp_trigger_price', '71000'); // directly set TP trigger price
+ * // or set the tp pnl, the TP trigger price will be calculated based on the current order price
+ * // setValue('tp_pnl', '300'); // you can also set tp_offset or tp_offset_percentage, same as the usage of useTPSL hook;
+ * // SL is similar to TP setting
+ * setValue('sl_price', '69000');
+ *
+ * // Submit the order data to the backend, and reset the hook state after the order is successfully created.
+ * // Note: If the order data is invalid, an error will be thrown.
+ * // If you want to retain the current order data after a successful order creation,
+ * // you can pass {resetOnSuccess: false} to `submit` function to prevent the hook from automatically resetting the order status.
+ * // Of course, you can also call `reset()` to manually reset the order status and use `resetMetaState()` to clear the error state.
+ * await submit();
+ * ```
+ */
+declare const useOrderEntry: (symbol: string, options?: Options$1) => OrderEntryReturn;
+
+declare const useOrderEntity: (order: {
+    symbol: string;
+    order_type: OrderType;
+    side: OrderSide;
+    reduce_only?: boolean;
+    [key: string]: any;
+}, options?: {
+    maxQty?: number;
+}) => {
+    errors: OrderValidationResult;
+    markPrice: number;
+    symbolsInfo: Record<string, <Key extends keyof _kodiak_finance_orderly_types.API.SymbolExt>(key: Key, defaultValue?: _kodiak_finance_orderly_types.API.SymbolExt[Key] | undefined) => _kodiak_finance_orderly_types.API.SymbolExt[Key]> & Record<string, () => _kodiak_finance_orderly_types.API.SymbolExt> & {
+        isNil: boolean;
+    };
+    validate: (this: unknown) => Promise<OrderValidationResult | null>;
+    clearErrors: () => void;
+};
+
+type RestrictedInfoReturns = ReturnType<typeof useRestrictedInfo>;
+interface RestrictedInfoOptions {
+    enableDefault?: boolean;
+    customRestrictedIps?: string[];
+    customRestrictedRegions?: string[];
+    customUnblockRegions?: string[];
+    content?: ReactNode | ((data: {
+        ip: string;
+        brokerName: string;
+    }) => ReactNode);
+}
+declare const useRestrictedInfo: (options?: RestrictedInfoOptions) => {
+    ip: string;
+    invalidRegions: string[];
+    restrictedOpen: boolean;
+    content: ReactNode | ((data: {
+        ip: string;
+        brokerName: string;
+    }) => ReactNode);
+    canUnblock: boolean;
+    accessRestricted: any;
+    setAccessRestricted: (value: boolean | undefined) => void;
+};
+
+type QueryOptions<T> = SWRConfiguration & {
+    formatter?: (data: any) => T;
+    accountId?: string;
+};
+declare function useSubAccountQuery<T>(query: Parameters<SWRHook>[0], options?: QueryOptions<T>): SWRResponse<T>;
+
+type HTTP_METHOD = "POST" | "PUT" | "DELETE" | "GET";
+type SubAccountMutationOptions<T, E> = SWRMutationConfiguration<T, E> & {
+    /** sub account id */
+    accountId?: string;
+};
+/**
+ * This hook is used to execute API requests for data mutation, such as POST, DELETE, PUT, etc.
+ */
+declare const useSubAccountMutation: <T, E>(
+/**
+ * The URL to send the request to. If the URL does not start with "http",
+ * it will be prefixed with the API base URL.
+ */
+url: string, 
+/**
+ * The HTTP method to use for the request. Defaults to "POST".
+ */
+method?: HTTP_METHOD, 
+/**
+ * The configuration object for the mutation.
+ * @see [useSWRMutation](https://swr.vercel.app/docs/mutation#api)
+ *
+ * @link https://swr.vercel.app/docs/mutation#api
+ */
+options?: SubAccountMutationOptions<T, E>) => readonly [(this: unknown, data: Record<string, any> | null, params?: Record<string, any> | undefined, options?: SubAccountMutationOptions<T, E> | undefined) => Promise<any>, {
+    readonly data: any;
+    readonly error: any;
+    readonly reset: () => void;
+    readonly isMutating: boolean;
+}];
+
+type Portfolio = {
+    holding?: API.Holding[];
+    totalCollateral: Decimal;
+    freeCollateral: Decimal;
+    totalValue: Decimal | null;
+    availableBalance: number;
+    unsettledPnL: number;
+    totalUnrealizedROI: number;
+};
+
+declare const useSubAccountDataObserver: (accountId?: string) => {
+    portfolio: Portfolio | undefined;
+    positions: API.PositionsTPSLExt;
+};
+
+type Options = {
+    accountId?: string;
+};
+declare const useSubAccountWS: (options: Options) => WS;
+
+/**
+ * The max withdrawal amount for the token
+ * if token is not provided, return the max withdrawal amount for USDC
+ */
+declare function useSubAccountMaxWithdrawal(options: {
+    token?: string;
+    unsettledPnL?: number;
+    freeCollateral: Decimal;
+    holdings?: API.Holding[];
+}): number;
+
+type PositionCloseOptions = {
+    position: API.PositionExt;
+    order: {
+        type: OrderType;
+        quantity: string;
+        price: string;
+    };
+};
+declare const usePositionClose: (options: PositionCloseOptions) => {
+    submit: () => Promise<any>;
+    isMutating: boolean;
+    side: OrderSide;
+    closeOrderData: Partial<OrderlyOrder>;
+    errors: OrderValidationResult | null;
+    calculate: typeof calculate;
+};
+
+declare const useMarketList: () => API.MarketInfoExt[];
+declare const useMarketMap: () => Record<string, API.MarketInfoExt> | null;
+
+export { type APIKeyItem, type AccountRewardsHistory, type AccountRewardsHistoryRow, 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, EpochStatus, type ExclusiveConfigProviderProps, ExtendedConfigStore, type Favorite, type FavoriteTab, type FundingRates, MaintenanceStatus, type MarginRatioReturn, type MarketsItem, MarketsStorageKey, type MarketsStore, MarketsType, type NewListing, ORDERLY_ORDERBOOK_DEPTH_KEY, type OrderBookItem, type OrderEntryReturn, type OrderMetadata, type OrderMetadataConfig, type OrderParams, type OrderValidationItem, type OrderValidationResult, type OrderbookData, type OrderbookOptions, type OrderlyConfigContextState, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, type PosterLayoutConfig, type PriceMode, type Recent, RefferalAPI, type RestrictedInfoOptions, type RestrictedInfoReturns, ScopeType, type StatusInfo, StatusProvider, type SymbolsInfo, TWType, type UseChainsOptions, type UseChainsReturnObject, type UseOrderEntryMetaState, WalletConnectorContext, type WalletConnectorContextState, type WalletRewards, type WalletRewardsHistoryReturns, type WalletRewardsItem, type WalletState, WsNetworkStatus, type chainFilter, type chainFilterFunc, checkNotional, cleanStringStyle, fetcher, type filteredChains$1 as filteredChains, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, noCacheConfig, parseJSON, useAccount, useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAssetsHistory, useAudioPlayer, useBalanceSubscription, useBalanceTopic, useBoolean, useChain, useChainInfo, useChains, useCheckReferralCode, useCollateral, useCommission, useComputedLTV, useConfig, useConvert, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEventEmitter, useFeeState, useFundingDetails, useFundingFeeHistory, useFundingRate, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, useGetReferralCode, useHoldingStream, useIndexPrice, useIndexPricesStream, useInfiniteQuery, useInternalTransfer, useKeyStore, useLazyQuery, useLeverage, useLeverageBySymbol, useLocalStorage, useMaintenanceStatus, useMarginRatio, useMarkPrice, useMarkPriceBySymbol, useMarkPricesStream, useMarket, useMarketList, useMarketMap, useMarketTradeStream, useMarkets, useMarketsStore, useMarketsStream, useMaxLeverage, useMaxQty, useMaxWithdrawal, useMediaQuery, useMemoizedFn, useMutation, useNetworkInfo, useOdosQuote, useOrderEntity, useOrderEntry, useOrderEntry$1 as useOrderEntry_deprecated, useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, type useQueryOptions, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useRestrictedInfo, useSessionStorage, useSettleSubscription, useSimpleDI, useStatisticsDaily, useStorageChain, useStorageLedgerAddress, useSubAccountDataObserver, useSubAccountMaxWithdrawal, useSubAccountMutation, useSubAccountQuery, useSubAccountWS, useSymbolInfo, useSymbolLeverage, useSymbolPriceRange, useSymbolsInfo, useSymbolsInfoStore, useTPSLOrder, useTickerStream, useTokenInfo, useTokensInfo, useTrack, useTrackingInstance, useTradingRewardsStatus, useTransfer, useTransferHistory, useUpdatedRef, useVaultsHistory, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWalletTopic, useWithdraw, useWsStatus, index as utils, _default as version };