import { a as MarketplaceClient, M as MarketplaceClientConfig, F as FetchCollectionTokensOptions, C as CollectionOrdersOptions, S as StatusType, d as CategoryType, e as CollectionListingsOptions, f as TokenDetailsOptions, h as RoyaltyFeeOptions, i as FetchTokenBalancesOptions, j as CollectionSummaryOptions, N as NormalizedCollection, k as FetchCollectionTokensResult, O as OrderModel, l as TokenDetails, m as FetchTokenBalancesResult, n as MarketplaceFees, o as RoyaltyFee } from '../types-BZP9_ZsO.js';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react from 'react';
import { ReactNode } from 'react';
import { QueryClient, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
import '@dojoengine/torii-wasm/types';
import 'starknet';
import '@dojoengine/sdk';

type MarketplaceClientStatus = "idle" | "loading" | "ready" | "error";
interface MarketplaceClientContextValue {
    client: MarketplaceClient | null;
    status: MarketplaceClientStatus;
    error: Error | null;
    refresh: () => Promise<MarketplaceClient | null>;
}
declare const MarketplaceClientContext: react.Context<MarketplaceClientContextValue | undefined>;
interface MarketplaceClientProviderBaseProps {
    children: ReactNode;
    queryClient?: QueryClient;
    onClientReady?: (client: MarketplaceClient) => void;
}
interface MarketplaceClientProviderWithConfig extends MarketplaceClientProviderBaseProps {
    config: MarketplaceClientConfig;
    client?: undefined;
}
interface MarketplaceClientProviderWithClient extends MarketplaceClientProviderBaseProps {
    config?: MarketplaceClientConfig;
    client: MarketplaceClient;
}
type MarketplaceClientProviderProps = MarketplaceClientProviderWithConfig | MarketplaceClientProviderWithClient;
declare function MarketplaceClientProvider(props: MarketplaceClientProviderProps): react_jsx_runtime.JSX.Element;
declare function useMarketplaceClient(): MarketplaceClientContextValue;

declare const marketplaceKeys: {
    all: readonly ["marketplace"];
    collection: (address: string) => readonly ["marketplace", "collection", string];
    collectionTokens: (options: FetchCollectionTokensOptions) => readonly ["marketplace", "collectionTokens", string, string | undefined, string | null | undefined, number | undefined, string[] | undefined, string | undefined];
    collectionOrders: (options: CollectionOrdersOptions) => readonly ["marketplace", "collectionOrders", string, string | undefined, StatusType | undefined, CategoryType | undefined, number | undefined, number[] | undefined];
    collectionListings: (options: CollectionListingsOptions) => readonly ["marketplace", "collectionListings", string, string | undefined, number | undefined, boolean | undefined];
    token: (options: TokenDetailsOptions) => readonly ["marketplace", "token", string, string, string | undefined];
    fees: () => readonly ["marketplace", "fees"];
    royaltyFee: (options: RoyaltyFeeOptions) => readonly ["marketplace", "royaltyFee", string, string, string];
    tokenBalances: (options: FetchTokenBalancesOptions) => readonly ["marketplace", "tokenBalances", string | undefined, string[] | undefined, string[] | undefined, string[] | undefined, string | null | undefined, number | undefined];
};
type QueryOptions<T> = Omit<UseQueryOptions<T, Error>, "queryKey" | "queryFn">;
declare function useMarketplaceCollection(options: CollectionSummaryOptions, queryOptions?: QueryOptions<NormalizedCollection | null> & {
    enabled?: boolean;
}): UseQueryResult<NormalizedCollection | null, Error>;
declare function useMarketplaceCollectionTokens(options: FetchCollectionTokensOptions, queryOptions?: QueryOptions<FetchCollectionTokensResult> & {
    enabled?: boolean;
}): UseQueryResult<FetchCollectionTokensResult, Error>;
declare function useMarketplaceCollectionOrders(options: CollectionOrdersOptions, queryOptions?: QueryOptions<OrderModel[]> & {
    enabled?: boolean;
}): UseQueryResult<OrderModel[], Error>;
declare function useMarketplaceCollectionListings(options: CollectionListingsOptions, queryOptions?: QueryOptions<OrderModel[]> & {
    enabled?: boolean;
}): UseQueryResult<OrderModel[], Error>;
declare function useMarketplaceToken(options: TokenDetailsOptions, queryOptions?: QueryOptions<TokenDetails | null> & {
    enabled?: boolean;
}): UseQueryResult<TokenDetails | null, Error>;
declare function useMarketplaceTokenBalances(options: FetchTokenBalancesOptions, queryOptions?: QueryOptions<FetchTokenBalancesResult> & {
    enabled?: boolean;
}): UseQueryResult<FetchTokenBalancesResult, Error>;
declare function useMarketplaceFees(queryOptions?: QueryOptions<MarketplaceFees | null> & {
    enabled?: boolean;
}): UseQueryResult<MarketplaceFees | null, Error>;
declare function useMarketplaceRoyaltyFee(options: RoyaltyFeeOptions, queryOptions?: QueryOptions<RoyaltyFee | null> & {
    enabled?: boolean;
}): UseQueryResult<RoyaltyFee | null, Error>;
/** Invalidate all marketplace queries */
declare function useInvalidateMarketplace(): () => Promise<void>;
/** Invalidate queries for a specific collection */
declare function useInvalidateCollection(address: string): () => Promise<void>;

export { MarketplaceClientContext, type MarketplaceClientContextValue, MarketplaceClientProvider, type MarketplaceClientProviderProps, type MarketplaceClientStatus, marketplaceKeys, useInvalidateCollection, useInvalidateMarketplace, useMarketplaceClient, useMarketplaceCollection, useMarketplaceCollectionListings, useMarketplaceCollectionOrders, useMarketplaceCollectionTokens, useMarketplaceFees, useMarketplaceRoyaltyFee, useMarketplaceToken, useMarketplaceTokenBalances };