import * as react from 'react';
import react__default, { FC, ReactNode, PropsWithChildren } from 'react';
import * as _orderly_network_types from '@orderly.network/types';
import { API, RouterAdapter } from '@orderly.network/types';
import * as _orderly_network_hooks from '@orderly.network/hooks';
import { useMarkets, MarketsType, FavoriteTab, MarketTabConfig, Favorite, MarketBuiltInTabType, BuiltInMarketTab } from '@orderly.network/hooks';
export { BuiltInMarketTab, CustomMarketTab, MarketBuiltInTabType, MarketCategoryComponentKey, MarketCategoryConfig, MarketCategoryContext, MarketTabConfig } from '@orderly.network/hooks';
import * as _orderly_network_ui from '@orderly.network/ui';
import { SortOrder, Column, TableSort, DataTableClassNames, FormattedTextProps } from '@orderly.network/ui';
import { LeftNavProps } from '@orderly.network/ui-scaffold';
import * as react_jsx_runtime from 'react/jsx-runtime';

type MarketsHeaderReturns = ReturnType<typeof useMarketsHeaderScript>;
declare const useMarketsHeaderScript: () => {
    markets: _orderly_network_hooks.MarketsItem[];
    news: any[];
    gainers: any[];
    losers: any[];
    total24Amount: number;
    totalOpenInterest: number;
    tvl: number;
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
};

/** -----------MarketsHeader start ------------ */
type MarketsHeaderProps = MarketsHeaderReturns & {
    className?: string;
};
declare const MarketsHeader: FC<MarketsHeaderProps>;

type MarketsHeaderWidgetProps = {
    className?: string;
};
declare const MarketsHeaderWidget: FC<MarketsHeaderWidgetProps>;

declare const MarketsDataListWidget: react__default.FC;

type FavoriteInstance = ReturnType<typeof useMarkets>[1];
type SortType = {
    sortKey: string;
    sortOrder: SortOrder;
};
type GetColumns = (favorite: FavoriteInstance, isFavoriteList: boolean) => Column[];
declare enum MarketsPageTab {
    Markets = "markets",
    Funding = "funding"
}
declare enum MarketsTabName {
    Favorites = "favorites",
    Recent = "recent",
    All = "all",
    Crypto = "crypto",
    Rwa = "rwa",
    PreTge = "preTge",
    NewListing = "newListing",
    Community = "community"
}
declare enum CommunitySubTabName {
    All = "all",
    MyListings = "myListings",
    OtherListings = "otherListings"
}
declare enum FundingTabName {
    Overview = "overview",
    Comparison = "comparison"
}

type UseMarketsDataListScript = ReturnType<typeof useMarketsDataListScript>;
declare function useMarketsDataListScript(): {
    activeTab: MarketsTabName;
    onTabChange: (value: string) => void;
    tabSort: Record<string, SortType>;
    onTabSort: (type: MarketsTabName | string) => (sort?: SortType) => void;
    searchValue: string | undefined;
};

type MarketsDataListProps = UseMarketsDataListScript;
declare const MarketsDataList: react__default.FC<MarketsDataListProps>;

type MarketsListFullWidgetProps = {
    type?: MarketsListFullType;
    initialSort?: SortType;
    dataFilter?: (data: any[]) => any[];
};
declare const MarketsListFullWidget: React.FC<MarketsListFullWidgetProps>;

type UseMarketsListFullScriptOptions = MarketsListFullWidgetProps;
type UseMarketsListFullReturn = ReturnType<typeof useMarketsListFullScript>;
declare const MarketsTypeMap: {
    all: MarketsType;
    crypto: MarketsType;
    new: MarketsType;
    rwa: MarketsType;
    preTge: MarketsType;
};
type MarketsListFullType = keyof typeof MarketsTypeMap;
declare const useMarketsListFullScript: (options: UseMarketsListFullScriptOptions) => {
    loading: boolean;
    dataSource: any[];
    isHiddenByLowVolumeFilter: boolean;
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    onSort: (options?: TableSort) => void;
    pagination: _orderly_network_ui.PaginationMeta;
    initialSort: TableSort;
};

type MarketsListFullProps = UseMarketsListFullReturn & {
    type?: MarketsListFullType;
};
declare const MarketsListFull: FC<MarketsListFullProps>;

type UseFavoritesListFullReturn = ReturnType<typeof useFavoritesListFullScript>;
declare const useFavoritesListFullScript: () => {
    loading: boolean;
    dataSource: any[];
    isHiddenByLowVolumeFilter: boolean;
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    onSort: (options?: _orderly_network_ui.TableSort) => void;
    pagination: _orderly_network_ui.PaginationMeta;
};

type FavoritesListFullProps = UseFavoritesListFullReturn & {
    emptyView?: ReactNode;
};
declare const FavoritesListFull: FC<FavoritesListFullProps>;

type FavoritesListFullWidgetProps = {
    emptyView?: ReactNode;
};
declare const FavoritesListFullWidget: React.FC<FavoritesListFullWidgetProps>;

type UseFavoritesDropdownMenuScriptOptions = {
    row: any;
    favorite: FavoriteInstance;
};
type UseFavoritesDropdownMenuScriptReturn = ReturnType<typeof useFavoritesDropdownMenuScript>;
declare function useFavoritesDropdownMenuScript(options: UseFavoritesDropdownMenuScriptOptions): {
    symbol: any;
    favoriteTabs: FavoriteTab[];
    open: boolean;
    onOpenChange: react.Dispatch<react.SetStateAction<boolean>>;
    inputVisible: boolean;
    selectedTabs: FavoriteTab[];
    value: string;
    onValueChange: react.Dispatch<react.SetStateAction<string>>;
    hide: () => void;
    hideInput: () => void;
    showInput: () => void;
    onCheck: (item: FavoriteTab, checked: boolean) => void;
    addTab: () => void;
    confirm: () => void;
};

type FavoritesDropdownMenuProps = PropsWithChildren<UseFavoritesDropdownMenuScriptReturn>;
declare const FavoritesDropdownMenu: React.FC<FavoritesDropdownMenuProps>;

type FavoritesDropdownMenuWidgetProps = PropsWithChildren<UseFavoritesDropdownMenuScriptOptions>;
declare const FavoritesDropdownMenuWidget: React.FC<FavoritesDropdownMenuWidgetProps>;

type UseFavoritesTabScriptOptions = {
    favorite: FavoriteInstance;
    size?: "sm" | "default";
};
type UseFavoritesTabScriptReturn = ReturnType<typeof useFavoritesTabScript>;
declare function useFavoritesTabScript(options: UseFavoritesTabScriptOptions): {
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    open: boolean;
    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
    container: react.RefObject<HTMLDivElement>;
    inputRef: react.RefObject<HTMLInputElement>;
    inputWidth: number;
    spanRef: react.RefObject<HTMLSpanElement>;
    editing: boolean;
    value: string;
    onValueChange: react.Dispatch<react.SetStateAction<string>>;
    onEdit: (item: any) => void;
    updateCurTab: (overLen: boolean) => void;
    addTab: () => void;
    delTab: (selectedTab: any) => void;
    scrollable: boolean;
};

type FavoritesTabProps = UseFavoritesTabScriptReturn & Pick<UseFavoritesTabScriptOptions, "size"> & {
    className?: string;
};
declare const FavoritesTab: React.FC<FavoritesTabProps>;

type FavoritesTabWidgetProps = UseFavoritesTabScriptOptions & {
    className?: string;
};
declare const FavoritesTabWidget: React.FC<FavoritesTabWidgetProps>;

type ExpandMarketsScriptOptions = {
    activeTab?: MarketsTabName;
    onTabChange?: (tab: MarketsTabName) => void;
};
type ExpandMarketsScriptReturn = ReturnType<typeof useExpandMarketsScript>;
declare function useExpandMarketsScript(options: ExpandMarketsScriptOptions): {
    activeTab: MarketsTabName;
    onTabChange: (value: string) => void;
    tabSort: Record<string, SortType>;
    onTabSort: (type: MarketsTabName | string) => (sort?: SortType) => void;
};

type ExpandMarketsProps = ExpandMarketsScriptReturn;
declare const ExpandMarkets: react__default.FC<ExpandMarketsProps>;

type MarketsProviderProps = {
    symbol?: string;
    onSymbolChange?: (symbol: API.Symbol) => void;
    navProps?: {
        logo?: {
            src: string;
            alt: string;
        };
        routerAdapter?: RouterAdapter;
        leftNav?: LeftNavProps;
    };
    comparisonProps?: {
        /**
         * Set Name of Exchanges in the comparison list.
         * @default 'Orderly'
         */
        exchangesName?: string;
        /**
         * Set Icon URL of Exchanges in the comparison list.
         * @default ""
         */
        exchangesIconSrc?: string;
    };
    tabs?: MarketTabConfig[];
};
declare const MarketsProvider: FC<PropsWithChildren<MarketsProviderProps>>;

type ExpandMarketsWidgetProps = MarketsProviderProps & ExpandMarketsScriptOptions;
declare const ExpandMarketsWidget: React.FC<ExpandMarketsWidgetProps>;

type SubMenuMarketsProps = {
    activeTab: MarketsTabName;
    onTabChange: (value: string) => void;
    className?: string;
    tabSort: Record<MarketsTabName, SortType | undefined>;
    onTabSort: (type: MarketsTabName) => (sort?: SortType) => void;
};
declare const SubMenuMarkets: react__default.FC<SubMenuMarketsProps>;

type SubMenuMarketsScriptOptions = {
    activeTab?: MarketsTabName;
    onTabChange?: (tab: MarketsTabName) => void;
};
declare function useSubMenuMarketsScript(options?: SubMenuMarketsScriptOptions): {
    readonly activeTab: MarketsTabName;
    readonly onTabChange: (value: string) => void;
    readonly tabSort: Record<string, SortType>;
    readonly onTabSort: (type: MarketsTabName | string) => (sort?: SortType) => void;
};

type SubMenuMarketsWidgetProps = MarketsProviderProps & SubMenuMarketsScriptOptions & Pick<SubMenuMarketsProps, "className">;
declare const SubMenuMarketsWidget: react__default.FC<SubMenuMarketsWidgetProps>;

type MarketsListWidgetProps = {
    type: MarketsTabName;
    getColumns?: GetColumns;
    panelSize?: "small" | "middle" | "large";
    tableClassNames?: DataTableClassNames;
    rowClassName?: string;
    initialSort?: SortType;
    onSort?: (sort?: SortType) => void;
    renderHeader?: (favorite: FavoriteInstance) => ReactNode;
    dataFilter?: (data: any[], options: {
        favorites: Favorite[];
        selectedFavoriteTab: FavoriteTab;
    }) => any[];
    emptyView?: ReactNode;
};
declare const MarketsListWidget: React.FC<MarketsListWidgetProps>;

type MarketsListScriptOptions = MarketsListWidgetProps;
type MarketsListScriiptReturn = ReturnType<typeof useMarketsListScript>;
declare const useMarketsListScript: (options: MarketsListScriptOptions) => {
    loading: boolean;
    dataSource: any[];
    isHiddenByLowVolumeFilter: boolean;
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    onSort: (options?: _orderly_network_ui.TableSort) => void;
    isFavoritesList: boolean;
};

type MarketsListProps = MarketsListScriiptReturn & Pick<MarketsListWidgetProps, "getColumns" | "panelSize" | "tableClassNames" | "rowClassName" | "initialSort" | "renderHeader" | "emptyView">;
declare const MarketsList: FC<MarketsListProps>;

type FundingOverviewReturn = ReturnType<typeof useFundingOverviewScript>;
declare const useFundingOverviewScript: () => {
    dataSource: any[];
    isLoading: boolean;
    pagination: _orderly_network_ui.PaginationMeta;
    onSort: (options?: _orderly_network_ui.TableSort) => void;
};

type FundingOverviewProps = FundingOverviewReturn;
declare const FundingOverview: FC<FundingOverviewProps>;

declare const FundingOverviewWidget: FC;

type FundingComparisonReturn = ReturnType<typeof useFundingComparisonScript>;
declare const useFundingComparisonScript: () => {
    dataSource: any[];
    isLoading: boolean;
    pagination: _orderly_network_ui.PaginationMeta;
    onSort: (options?: _orderly_network_ui.TableSort) => void;
};

declare const FundingComparison: FC<FundingComparisonReturn>;

declare const FundingComparisonWidget: FC;

type CollapseMarketsProps = {
    dataSource: any[];
};
declare const CollapseMarkets: React.FC<CollapseMarketsProps>;

type SideMarketsScriptOptions = {
    panelSize?: "small" | "middle" | "large";
    collapsed?: boolean;
    onPanelSizeChange?: React.Dispatch<React.SetStateAction<"small" | "middle" | "large">>;
};
type SideMarketsScriptReturn = ReturnType<typeof useSideMarketsScript>;
declare const useSideMarketsScript: (options?: SideMarketsScriptOptions) => {
    readonly activeTab: MarketsTabName;
    readonly onTabChange: (value: MarketsTabName) => void;
    readonly tabSort: Record<string, SortType>;
    readonly panelSize: "small" | "middle" | "large";
};

type SideMarketsProps = SideMarketsScriptReturn & {
    className?: string;
} & {
    panelSize?: "small" | "middle" | "large";
};
declare const SideMarkets: react__default.FC<SideMarketsProps>;

type SideMarketsWidgetProps = MarketsProviderProps & Partial<Pick<SideMarketsProps, "className">> & {
    panelSize?: "small" | "middle" | "large";
    collapsed?: boolean;
};
declare const SideMarketsWidget: react__default.FC<SideMarketsWidgetProps>;

type DropDownMarketsScriptReturn = ReturnType<typeof useDropDownMarketsScript>;
declare function useDropDownMarketsScript(): {
    activeTab: MarketsTabName;
    onTabChange: (value: string) => void;
    open: boolean;
    onOpenChange: react.Dispatch<react.SetStateAction<boolean>>;
    hide: () => void;
    tabSort: Record<string, SortType>;
    onTabSort: (type: MarketsTabName | string) => (sort?: SortType) => void;
};

type DropDownMarketsProps = DropDownMarketsScriptReturn & {
    contentClassName?: string;
};
declare const DropDownMarkets: React.FC<PropsWithChildren<DropDownMarketsProps>>;
declare const DropDownMarketsConetnt: React.FC<DropDownMarketsProps>;

declare const useDropDownMarketsColumns: () => (favorite: FavoriteInstance, isFavoriteList?: boolean) => Column[];

type DropDownMarketsWidgetProps = MarketsProviderProps & Pick<DropDownMarketsProps, "contentClassName">;
declare const DropDownMarketsWidget: react__default.FC<PropsWithChildren<DropDownMarketsWidgetProps>>;

type MarketsSheetScriptReturn = ReturnType<typeof useMarketsSheetScript>;
declare function useMarketsSheetScript(): {
    tabSort: Record<string, SortType>;
    onTabSort: (type: MarketsTabName | string) => (sort?: SortType) => void;
    activeTab: any;
    onTabChange: (value: MarketsTabName) => void;
};

type MarketsSheetProps = MarketsSheetScriptReturn & {
    className?: string;
};
declare const MarketsSheet: React.FC<MarketsSheetProps>;

type MarketsSheetWidgetProps = MarketsProviderProps & Partial<Pick<MarketsSheetProps, "className">>;
declare const MarketsSheetWidget: react__default.FC<MarketsSheetWidgetProps>;

type UseSymbolInfoBarScriptOptions = {
    symbol: string;
};
type UseSymbolInfoBarScriptReturn = ReturnType<typeof useSymbolInfoBarScript>;
declare function useSymbolInfoBarScript(options: UseSymbolInfoBarScriptOptions): {
    symbol: string;
    data: _orderly_network_types.API.MarketInfo & {
        change?: number;
        "24h_change"?: number;
    };
    leverage: number | undefined;
    isRwa: boolean;
    open: boolean | undefined;
    closeTimeInterval: number | undefined;
    openTimeInterval: number | undefined;
};

type SymbolInfoBarProps = Pick<MarketsProviderProps, "onSymbolChange"> & UseSymbolInfoBarScriptReturn & {
    className?: string;
    trailing?: ReactNode;
    onSymbol?: () => void;
};
declare const SymbolInfoBar: FC<SymbolInfoBarProps>;

type SymbolInfoBarWidgetPros = UseSymbolInfoBarScriptOptions & Pick<SymbolInfoBarProps, "className" | "trailing" | "onSymbol">;
declare const SymbolInfoBarWidget: React.FC<SymbolInfoBarWidgetPros>;

type UseSymbolInfoBarFullScriptOptions = {
    symbol: string;
};
type UseSymbolInfoBarFullScriptReturn = ReturnType<typeof useSymbolInfoBarFullScript>;
declare function useSymbolInfoBarFullScript(options: UseSymbolInfoBarFullScriptOptions): {
    symbol: string;
    isFavorite: boolean;
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    data: _orderly_network_types.API.MarketInfo & {
        change?: number;
        "24h_change"?: number;
    };
    quotoDp: number;
    openInterest: string;
    fundingRate: {
        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;
    };
    containerRef: react.RefObject<HTMLDivElement>;
    leadingElementRef: react.RefObject<HTMLDivElement>;
    tailingElementRef: react.RefObject<HTMLDivElement>;
    leadingVisible: boolean;
    tailingVisible: boolean;
    onScoll: (direction: string) => void;
    fundingPeriod: string;
    capFunding: string;
    floorFunding: string;
    isRwa: boolean;
    open: boolean | undefined;
    closeTimeInterval: number | undefined;
    openTimeInterval: number | undefined;
};

/** Part 1: Community-listed risk notice banner */
declare const SymbolInfoBarRiskNotice: react__default.FC<{
    className?: string;
    visible: boolean;
    symbolWithBroker: string;
    brokerName: string;
    isPreTge?: boolean;
    /** When true, height follows content instead of fixed 46px (e.g. for mobile) */
    autoHeight?: boolean;
}>;
type SymbolInfoBarFullProps = Pick<MarketsProviderProps, "onSymbolChange"> & UseSymbolInfoBarFullScriptReturn & {
    className?: string;
    trailing?: ReactNode;
    closeCountdown?: () => void;
    showCountdown?: boolean;
};
declare const SymbolInfoBarFull: react__default.FC<SymbolInfoBarFullProps>;

type SymbolInfoBarFullWidgetPros = UseSymbolInfoBarFullScriptOptions & Pick<SymbolInfoBarFullProps, "className" | "trailing"> & Pick<MarketsProviderProps, "onSymbolChange"> & {
    closeCountdown?: () => void;
    showCountdown?: boolean;
};
declare const SymbolInfoBarFullWidget: FC<SymbolInfoBarFullWidgetPros>;

type MarketType = "all" | "crypto" | "recent" | "newListing" | "rwa" | "preTge" | "favorites" | (string & {});
type HorizontalMarketsScriptOptions = {
    symbols?: string[];
    maxItems?: number;
    defaultMarketType?: MarketType;
};
type HorizontalMarketsScriptReturn = ReturnType<typeof useHorizontalMarketsScript>;
declare const useHorizontalMarketsScript: (options?: HorizontalMarketsScriptOptions) => {
    readonly symbols: any[];
    readonly tickerData: Record<string, {
        "24h_close": number;
        change: number;
        quote_dp: number;
    }>;
    readonly currentSymbol: string | undefined;
    readonly onSymbolClick: (symbol: string) => void;
    readonly selectedMarketType: any;
    readonly onMarketTypeChange: (marketType: MarketType) => void;
};

type DropdownPos = "top" | "bottom";
type MarketTypeFilterProps = {
    selectedMarketType: MarketType;
    onMarketTypeChange: (marketType: MarketType) => void;
    className?: string;
    position?: DropdownPos;
    tabs?: MarketTabConfig[];
};
declare const MarketTypeFilter: react__default.FC<MarketTypeFilterProps>;

type HorizontalMarketsProps = HorizontalMarketsScriptReturn & {
    className?: string;
    dropdownPos?: DropdownPos;
};
declare const HorizontalMarkets: react__default.NamedExoticComponent<HorizontalMarketsProps>;

type HorizontalMarketsWidgetProps = MarketsProviderProps & Partial<Pick<HorizontalMarketsProps, "symbols" | "className">> & {
    maxItems?: number;
    defaultMarketType?: MarketType;
    dropdownPos?: DropdownPos;
};
declare const HorizontalMarketsWidget: react__default.FC<HorizontalMarketsWidgetProps>;

interface MarketItemProps {
    symbol: string;
    tickerData: {
        "24h_close": number;
        change: number;
        quote_dp: number;
    };
    isActive: boolean;
    onSymbolClick: (symbol: string) => void;
}
declare const MarketItem: react__default.NamedExoticComponent<MarketItemProps>;

type UseNewListingListReturn = ReturnType<typeof useNewListingListScript>;
declare const useNewListingListScript: () => {
    loading: boolean;
    dataSource: any[];
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    onSort: (options?: _orderly_network_ui.TableSort) => void;
};

type NewListingListWidgetProps = {
    getColumns?: GetColumns;
    collapsed?: boolean;
    tableClassNames?: DataTableClassNames;
    rowClassName?: string;
};
declare const NewListingListWidget: React.FC<NewListingListWidgetProps>;

type NewListingListProps = UseNewListingListReturn & NewListingListWidgetProps;
declare const NewListingList: FC<NewListingListProps>;

type UseFavoritesListReturn = ReturnType<typeof useFavoritesListScript>;
declare const useFavoritesListScript: () => {
    loading: boolean;
    dataSource: any[];
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    onSort: (options?: _orderly_network_ui.TableSort) => void;
};

type FavoritesListWidgetProps = {
    getColumns?: GetColumns;
    collapsed?: boolean;
    tableClassNames?: DataTableClassNames;
    rowClassName?: string;
};
declare const FavoritesListWidget: React.FC<FavoritesListWidgetProps>;

type FavoritesListProps = UseFavoritesListReturn & FavoritesListWidgetProps;
declare const FavoritesList: FC<FavoritesListProps>;

type UseRecentListReturn = ReturnType<typeof useRecentListScript>;
declare const useRecentListScript: () => {
    loading: boolean;
    dataSource: any[];
    favorite: {
        favoriteTabs: _orderly_network_hooks.FavoriteTab[];
        favorites: {
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[];
        recent: _orderly_network_hooks.Recent[];
        newListing: _orderly_network_hooks.NewListing[];
        tabSort: {
            [x: string]: {
                sortKey: string;
                sortOrder: string;
            };
        };
        selectedFavoriteTab: _orderly_network_hooks.FavoriteTab;
        updateFavorites: react.Dispatch<react.SetStateAction<{
            tabs: _orderly_network_hooks.FavoriteTab[];
            name: string;
        }[]>>;
        updateFavoriteTabs: (tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], operator?: {
            add?: boolean;
            update?: boolean;
            delete?: boolean;
        }) => void;
        updateSymbolFavoriteState: (symbol: _orderly_network_types.API.MarketInfoExt, tab: _orderly_network_hooks.FavoriteTab | _orderly_network_hooks.FavoriteTab[], remove?: boolean) => void;
        pinToTop: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        addToHistory: (symbol: _orderly_network_types.API.MarketInfoExt) => void;
        updateSelectedFavoriteTab: (tab: _orderly_network_hooks.FavoriteTab) => void;
        updateTabsSortState: (tabId: string, sortKey: string, sortOrder: "desc" | "asc") => void;
    };
    onSort: (options?: _orderly_network_ui.TableSort) => void;
};

type RecentListWidgetProps = {
    getColumns?: GetColumns;
    collapsed?: boolean;
    tableClassNames?: DataTableClassNames;
    rowClassName?: string;
};
declare const RecentListWidget: React.FC<RecentListWidgetProps>;

type RecentListProps = UseRecentListReturn & RecentListWidgetProps;
declare const RecentList: FC<RecentListProps>;

type MarketsHomePageProps = MarketsProviderProps & {
    className?: string;
};
declare const MarketsHomePage: FC<MarketsHomePageProps>;

type SymbolDisplayProps = FormattedTextProps & {
    showBadge?: boolean;
    /** Market row data used for RWA status fields. */
    record?: any;
};
declare const SymbolDisplay: react.MemoExoticComponent<(props: SymbolDisplayProps) => react_jsx_runtime.JSX.Element>;

/**
 * Pre-built builtIn constants for config function's context.builtIn.
 * Each entry is a built-in tab reference.
 */
declare const builtInTabs: Record<MarketBuiltInTabType, BuiltInMarketTab>;

export { CollapseMarkets, type CollapseMarketsProps, CommunitySubTabName, DropDownMarkets, DropDownMarketsConetnt, DropDownMarketsWidget, ExpandMarkets, ExpandMarketsWidget, type FavoriteInstance, FavoritesDropdownMenu, FavoritesDropdownMenuWidget, FavoritesList, FavoritesListFull, FavoritesListFullWidget, FavoritesListWidget, FavoritesTab, FavoritesTabWidget, FundingComparison, FundingComparisonWidget, FundingOverview, FundingOverviewWidget, FundingTabName, type GetColumns, HorizontalMarkets, type HorizontalMarketsProps, type HorizontalMarketsScriptOptions, type HorizontalMarketsScriptReturn, HorizontalMarketsWidget, type HorizontalMarketsWidgetProps, MarketItem, type MarketItemProps, type MarketType, MarketTypeFilter, type MarketTypeFilterProps, MarketsDataList, MarketsDataListWidget, MarketsHeader, MarketsHeaderWidget, MarketsHomePage, MarketsList, MarketsListFull, MarketsListFullWidget, MarketsListWidget, MarketsPageTab, MarketsProvider, MarketsSheet, MarketsSheetWidget, MarketsTabName, NewListingList, NewListingListWidget, RecentList, RecentListWidget, SideMarkets, SideMarketsWidget, type SortType, SubMenuMarkets, type SubMenuMarketsProps, SubMenuMarketsWidget, SymbolDisplay, SymbolInfoBar, SymbolInfoBarFull, type SymbolInfoBarFullProps, SymbolInfoBarFullWidget, SymbolInfoBarRiskNotice, SymbolInfoBarWidget, builtInTabs, useDropDownMarketsColumns, useDropDownMarketsScript, useExpandMarketsScript, useFavoritesDropdownMenuScript, useFavoritesListFullScript, useFavoritesListScript, useFavoritesTabScript, useFundingComparisonScript, useFundingOverviewScript, useHorizontalMarketsScript, useMarketsDataListScript, useMarketsHeaderScript, useMarketsListFullScript, useMarketsListScript, useMarketsSheetScript, useNewListingListScript, useRecentListScript, useSideMarketsScript, useSubMenuMarketsScript, useSymbolInfoBarFullScript, useSymbolInfoBarScript };