import * as _tanstack_react_query from '@tanstack/react-query';
import { QueryKey, DefaultError, QueryObserverResult } from '@tanstack/react-query';
import * as _slicekit_core from '@slicekit/core';
import { GetSlicerOrdersParams, GetSlicerProductsParams, PosLocationsResponse, GetPosLocationsParams, GetSlicerOrdersResponseForInclude, GetSlicerProductsResponseForInclude, ProductPriceResult, getProductPrice, GetSlicersParams } from '@slicekit/core';
import * as _slicekit_commerce from '@slicekit/commerce';
import { PaginationMetadata, PaginationParams, PaginatedData } from '@slicekit/commerce';
import * as react from 'react';
import { Dispatch, SetStateAction } from 'react';
import { ReadContractsErrorType, Config } from '@wagmi/core';
import { fundsModuleConfig, iPriceFeedConfig, productsModuleConfig, sliceCoreConfig, slicerManagerConfig, fundsModuleAddress } from '@slicekit/abi/deployments';
import { SliceAccountClientCall, SliceAccountClientExecutionError, SliceAccountClient } from '@slicekit/wallet/execution';
import { Abi, ContractFunctionName, ContractFunctionParameters, GetValue, Hex, erc20Abi, WalletCapabilities, Capabilities } from 'viem';
import { registryProductActionAbi, slicerAbi } from '@slicekit/abi';

interface UsePaginationParams<TItem> {
    queryKey?: QueryKey;
    initialItems: TItem[];
    initialPagination: PaginationMetadata | null | undefined;
    fetchPage: (params: PaginationParams) => Promise<PaginatedData<TItem>>;
    enabled?: boolean;
    getItemKey?: (item: TItem) => string | number;
    isComplete?: (items: TItem[], pagination: PaginationMetadata | null) => boolean;
    mergeItems?: (currentItems: TItem[], nextItems: TItem[]) => TItem[];
    onError?: (error: DefaultError) => void;
    stopOnError?: boolean;
    staleTime?: number;
}
interface TablePaginationState {
    pageIndex: number;
    pageSize: number;
}
type TablePaginationUpdater = TablePaginationState | ((current: TablePaginationState) => TablePaginationState);
type TableStateUpdater<TState> = TState | ((current: TState) => TState);
type TableStateChangeHandler<TState> = (updater: TableStateUpdater<TState>) => void;
type PaginatedTableQueryState<TColumnFilters, TSorting> = {
    columnFilters: TColumnFilters;
    pagination: TablePaginationState;
    sorting: TSorting;
};
type PaginatedTablePage<TItem, TPagination extends PaginationMetadata = PaginationMetadata> = {
    data: TItem[];
    pagination: TPagination;
};
type PaginatedTableCacheSnapshot<TPage> = Array<readonly [QueryKey, TPage | undefined]>;
type PaginatedTablePageDataUpdater<TItem, TPage extends PaginatedTablePage<TItem>> = (data: TItem[], page: TPage) => TItem[];
type UsePaginatedTableQueryFetchParams<TQuery extends PaginationParams> = {
    query: TQuery;
    knownTotal?: number;
    signal?: AbortSignal;
};
interface UsePaginatedTableQueryParams<TItem, TQuery extends PaginationParams, TPage extends PaginatedTablePage<TItem>, TQueryKey extends QueryKey = QueryKey> {
    activeQuery: TQuery;
    initialQuery: TQuery;
    initialResult: TPage;
    queryKey: (query: TQuery) => TQueryKey;
    fetchPage: (params: UsePaginatedTableQueryFetchParams<TQuery>) => Promise<TPage>;
    getQueryIdentity: (query: TQuery) => string;
    normalizeQuery?: (query: TQuery) => TQuery;
    onQueryTransition?: (query: TQuery) => void;
    queryCacheKey?: QueryKey;
    activeRequestDelayMs?: number;
    prefetchedPages?: number;
    staleTime?: number;
}
interface UsePaginatedTableQueryResult<TItem, TQuery extends PaginationParams, TPage extends PaginatedTablePage<TItem>> {
    pageResult: TPage;
    currentPagination: TPage["pagination"];
    isPagePending: boolean;
    isFetching: boolean;
    hasPageData: boolean;
    setPageData: Dispatch<SetStateAction<TItem[]>>;
    prefetchPage: (pageIndex: number, pageSize?: number, baseQuery?: TQuery) => void;
    prefetchReachablePages: (pagination: TPage["pagination"], query?: TQuery) => void;
    getCachedPagesData: () => PaginatedTableCacheSnapshot<TPage>;
    restoreCachedPagesData: (snapshot: PaginatedTableCacheSnapshot<TPage>) => void;
    setCachedPagesData: (updater: PaginatedTablePageDataUpdater<TItem, TPage>) => void;
    cancelCachedPages: () => Promise<void>;
    invalidateCachedPages: () => Promise<void>;
    handleQueryTransition: (query: TQuery) => void;
}
interface UsePaginatedTableStateQueryParams<TItem, TQuery extends PaginationParams, TPage extends PaginatedTablePage<TItem>, TColumnFilters, TSorting, TQueryKey extends QueryKey = QueryKey> extends Omit<UsePaginatedTableQueryParams<TItem, TQuery, TPage, TQueryKey>, "activeQuery"> {
    columnFilters: TColumnFilters;
    paginationState: TablePaginationState;
    sorting: TSorting;
    setColumnFilters: TableStateChangeHandler<TColumnFilters>;
    setPaginationState: TableStateChangeHandler<TablePaginationState>;
    setSorting: TableStateChangeHandler<TSorting>;
    tableStateToQuery: (state: PaginatedTableQueryState<TColumnFilters, TSorting>) => TQuery;
    clampPageToTotal?: boolean;
    prefetchOnPageData?: boolean;
}
interface UsePaginatedTableStateQueryResult<TItem, TQuery extends PaginationParams, TPage extends PaginatedTablePage<TItem>, TColumnFilters, TSorting> extends UsePaginatedTableQueryResult<TItem, TQuery, TPage> {
    activeQuery: TQuery;
    handleColumnFilters: TableStateChangeHandler<TColumnFilters>;
    handleSorting: TableStateChangeHandler<TSorting>;
    handlePagination: TableStateChangeHandler<TablePaginationState>;
}
declare const createPendingPagination: <TPagination extends PaginationMetadata = PaginationMetadata>(query: PaginationParams, total: number) => TPagination;
declare const resolveTablePaginationState: ({ current, updater }: {
    current: TablePaginationState;
    updater: TablePaginationUpdater;
}) => TablePaginationState;
declare const resolveTableState: <TState>({ current, updater }: {
    current: TState;
    updater: TableStateUpdater<TState>;
}) => TState;

interface UseLoadMoreOnScrollParams {
    hasMore: boolean;
    isLoading?: boolean;
    onLoadMore?: () => void;
    enabled?: boolean;
    offset?: number;
    checkOnRender?: boolean;
}
interface UseLoadMoreOnIntersectionParams {
    hasMore: boolean;
    isLoading?: boolean;
    onLoadMore?: () => void;
    enabled?: boolean;
    root?: IntersectionObserverInit["root"];
    rootMargin?: IntersectionObserverInit["rootMargin"];
    threshold?: IntersectionObserverInit["threshold"];
    requestKey?: string | number;
}

type SlicerProductsItem<TInclude extends GetSlicerProductsParams["include"]> = GetSlicerProductsResponseForInclude<TInclude>["data"][number];
type SlicerOrdersItem<TInclude extends GetSlicerOrdersParams["include"]> = GetSlicerOrdersResponseForInclude<TInclude>["data"][number];
type ApiAuthKey = "apiKey" | "signer";
type ApiRequestAuth<TParams> = TParams extends object ? Pick<TParams, Extract<keyof TParams, ApiAuthKey>> : never;
type ApiPageQuery<TParams> = TParams extends object ? Omit<TParams, ApiAuthKey | "page" | "limit"> : never;
type ApiPaginationRequest<TParams> = TParams extends object ? Omit<TParams, "page" | "limit"> : never;
type SlicerProductsQueryBase<TInclude extends GetSlicerProductsParams["include"]> = ApiPageQuery<GetSlicerProductsParams<TInclude>>;
type SlicerProductsRequestBase<TInclude extends GetSlicerProductsParams["include"]> = ApiPaginationRequest<GetSlicerProductsParams<TInclude>>;
type SlicerProductsAuth<TInclude extends GetSlicerProductsParams["include"]> = ApiRequestAuth<GetSlicerProductsParams<TInclude>>;
type SlicerOrdersQueryBase<TInclude extends GetSlicerOrdersParams["include"]> = ApiPageQuery<GetSlicerOrdersParams<TInclude>>;
type SlicerOrdersRequestBase<TInclude extends GetSlicerOrdersParams["include"]> = ApiPaginationRequest<GetSlicerOrdersParams<TInclude>>;
type SlicerOrdersAuth<TInclude extends GetSlicerOrdersParams["include"]> = ApiRequestAuth<GetSlicerOrdersParams<TInclude>>;
type SlicerProductsPageQuery<TInclude extends GetSlicerProductsParams["include"] = undefined> = SlicerProductsQueryBase<TInclude> & {
    page: number;
    limit: number;
};
type SlicerOrdersPageQuery<TInclude extends GetSlicerOrdersParams["include"] = undefined> = SlicerOrdersQueryBase<TInclude> & {
    page: number;
    limit: number;
};
type UseSlicerProductsParams<TInclude extends GetSlicerProductsParams["include"] = undefined> = SlicerProductsRequestBase<TInclude> & Omit<UsePaginationParams<SlicerProductsItem<TInclude>>, "fetchPage" | "initialItems" | "initialPagination"> & {
    limit?: number;
    initialData?: GetSlicerProductsResponseForInclude<TInclude> | null;
};
type UseSlicerOrdersParams<TInclude extends GetSlicerOrdersParams["include"] = undefined> = SlicerOrdersRequestBase<TInclude> & Omit<UsePaginationParams<SlicerOrdersItem<TInclude>>, "fetchPage" | "initialItems" | "initialPagination"> & {
    limit?: number;
    initialData?: GetSlicerOrdersResponseForInclude<TInclude> | null;
};
type UseSlicerProductsTableQueryParams<TInclude extends GetSlicerProductsParams["include"] = undefined> = SlicerProductsAuth<TInclude> & Omit<UsePaginatedTableQueryParams<SlicerProductsItem<TInclude>, SlicerProductsPageQuery<TInclude>, GetSlicerProductsResponseForInclude<TInclude>>, "fetchPage" | "getQueryIdentity" | "queryKey"> & {
    queryKey?: (query: SlicerProductsPageQuery<TInclude>) => QueryKey;
    getQueryIdentity?: (query: SlicerProductsPageQuery<TInclude>) => string;
};
type UseSlicerOrdersTableQueryParams<TInclude extends GetSlicerOrdersParams["include"] = undefined> = SlicerOrdersAuth<TInclude> & Omit<UsePaginatedTableQueryParams<SlicerOrdersItem<TInclude>, SlicerOrdersPageQuery<TInclude>, GetSlicerOrdersResponseForInclude<TInclude>>, "fetchPage" | "getQueryIdentity" | "queryKey"> & {
    queryKey?: (query: SlicerOrdersPageQuery<TInclude>) => QueryKey;
    getQueryIdentity?: (query: SlicerOrdersPageQuery<TInclude>) => string;
};
type UsePosLocationsParams<TData = PosLocationsResponse> = GetPosLocationsParams & {
    enabled?: boolean;
    queryKey?: QueryKey;
    staleTime?: number;
    select?: (data: PosLocationsResponse) => TData;
};

type SliceWalletStaticContractConfig = {
    FundsModule: typeof fundsModuleConfig;
    IPriceFeed: typeof iPriceFeedConfig;
    ProductsModule: typeof productsModuleConfig;
    SliceCore: typeof sliceCoreConfig;
    SlicerManager: typeof slicerManagerConfig;
};
type SliceWalletExternalContractConfig = {
    ERC20: {
        abi: typeof erc20Abi;
    };
    RegistryProductAction: {
        abi: typeof registryProductActionAbi;
    };
    Slicer: {
        abi: typeof slicerAbi;
    };
};
type SliceWalletContractConfig = SliceWalletStaticContractConfig & SliceWalletExternalContractConfig;
type SliceWalletContractAbi<contract extends SliceWalletContractName> = SliceWalletContractConfig[contract]["abi"];
type SliceWalletContractFunctionCall<abi extends Abi, functionName extends ContractFunctionName<abi, "nonpayable" | "payable"> = ContractFunctionName<abi, "nonpayable" | "payable">> = functionName extends ContractFunctionName<abi, "nonpayable" | "payable"> ? Omit<ContractFunctionParameters<abi, "nonpayable" | "payable", functionName>, "abi" | "address"> & GetValue<abi, functionName, bigint> & {
    dataSuffix?: Hex;
} : never;
type SliceWalletContractName = keyof SliceWalletContractConfig;
type SliceWalletStaticContractName = keyof SliceWalletStaticContractConfig;
type SliceWalletExternalContractName = keyof SliceWalletExternalContractConfig;
type SliceWalletConfiguredContractCall<contract extends SliceWalletStaticContractName = SliceWalletStaticContractName> = {
    [contractName in contract]: {
        contract: contractName;
    } & SliceWalletContractFunctionCall<SliceWalletContractAbi<contractName>>;
}[contract];
type SliceWalletExternalContractCall<contract extends SliceWalletExternalContractName = SliceWalletExternalContractName> = {
    [contractName in contract]: {
        contract: contractName;
        address: Hex;
    } & SliceWalletContractFunctionCall<SliceWalletContractAbi<contractName>>;
}[contract];
type SliceWalletRawCall = {
    data?: Hex;
    to: Hex;
    value?: bigint;
};
type SliceWalletCall = SliceWalletConfiguredContractCall | SliceWalletExternalContractCall | SliceWalletRawCall;
type SliceWalletCallLog = {
    address: Hex;
    data: Hex;
    topics: readonly Hex[];
};
type SliceWalletCallReceipt = {
    blockHash: Hex;
    blockNumber: bigint;
    gasUsed: bigint;
    logs: SliceWalletCallLog[];
    status: "success" | "reverted";
    transactionHash: Hex;
};
type SliceWalletCallResult = {
    type: "batch";
    sendCallsId: string;
    transactionHash: Hex | null;
    receipts: SliceWalletCallReceipt[];
} | {
    type: "transactions";
    sendCallsId?: string;
    transactionHash: Hex;
    receipts: SliceWalletCallReceipt[];
} | {
    type: "empty";
    transactionHash: null;
    receipts: [];
};
type SliceWalletCallSubmitOptions = {
    capabilities?: WalletCapabilities;
    onSubmitted?: () => void;
    useSmartAccount?: boolean;
};
type SliceSendWalletCalls = (calls: SliceWalletCall[], options?: SliceWalletCallSubmitOptions) => Promise<SliceWalletCallResult>;

type SlicerWithdrawableFundsCurrency = {
    address: `0x${string}`;
    symbol: string;
    decimals: number;
};
type SlicerWithdrawableCurrency = SlicerWithdrawableFundsCurrency & {
    unreleasedRawAmount: bigint;
    fundsModuleRawAmount: bigint;
    rawAmount: bigint;
    formattedAmount: number;
};
type SlicerWithdrawableContractResult = {
    result?: bigint | readonly [bigint, bigint];
};
type SlicerWithdrawableReadContractsData = readonly SlicerWithdrawableContractResult[];
type SlicerWithdrawableRefetchResult = QueryObserverResult<SlicerWithdrawableReadContractsData, ReadContractsErrorType>;
type UseSlicerWithdrawableFundsResult = {
    data: SlicerWithdrawableCurrency[];
    error: ReadContractsErrorType | null;
    isLoading: boolean;
    isFetching: boolean;
    refetch: () => Promise<readonly [SlicerWithdrawableRefetchResult, SlicerWithdrawableRefetchResult]>;
};

declare function usePosLocations<TData = PosLocationsResponse>({ slicerId, signer, include, enabled, queryKey, staleTime, select }: UsePosLocationsParams<TData>): _tanstack_react_query.UseQueryResult<NoInfer<TData>, Error>;

type ProductPriceParams = Parameters<typeof getProductPrice>[1];
type UseProductPriceParams<TData> = ProductPriceParams & {
    enabled?: boolean;
    select?: (data: ProductPriceResult | null) => TData;
};
declare const useProductPrice: <TData = ProductPriceResult | null>(config: Config, { product, variantId, buyer, currency, fiatCurrency, priceResolution, quantity, dynamicPriceBufferBps, enabled, select }: UseProductPriceParams<TData>) => _tanstack_react_query.UseQueryResult<NoInfer<TData>, Error>;

declare function useSlicerOrders<const TInclude extends GetSlicerOrdersParams["include"] = undefined>({ limit, initialData, queryKey, enabled, getItemKey, isComplete, mergeItems, onError, stopOnError, staleTime, ...params }: UseSlicerOrdersParams<TInclude>): {
    items: GetSlicerOrdersResponseForInclude<TInclude>["data"][number][];
    setItems: react.Dispatch<react.SetStateAction<GetSlicerOrdersResponseForInclude<TInclude>["data"][number][]>>;
    pagination: _slicekit_commerce.PaginationMetadata | null;
    setPagination: react.Dispatch<react.SetStateAction<_slicekit_commerce.PaginationMetadata | null>>;
    error: Error | null;
    hasNextPage: boolean;
    isFetchingNextPage: boolean;
    nextPage: number | null;
    fetchNextPage: () => Promise<void>;
};
declare function useSlicerOrdersTableQuery<const TInclude extends GetSlicerOrdersParams["include"] = undefined>({ queryKey, getQueryIdentity, ...params }: UseSlicerOrdersTableQueryParams<TInclude>): UsePaginatedTableQueryResult<GetSlicerOrdersResponseForInclude<TInclude>["data"][number], SlicerOrdersPageQuery<TInclude>, GetSlicerOrdersResponseForInclude<TInclude>>;

declare function useSlicerProducts<const TInclude extends GetSlicerProductsParams["include"] = undefined>({ limit, initialData, queryKey, enabled, getItemKey, isComplete, mergeItems, onError, stopOnError, staleTime, ...params }: UseSlicerProductsParams<TInclude>): {
    items: GetSlicerProductsResponseForInclude<TInclude>["data"][number][];
    setItems: react.Dispatch<react.SetStateAction<GetSlicerProductsResponseForInclude<TInclude>["data"][number][]>>;
    pagination: _slicekit_commerce.PaginationMetadata | null;
    setPagination: react.Dispatch<react.SetStateAction<_slicekit_commerce.PaginationMetadata | null>>;
    error: Error | null;
    hasNextPage: boolean;
    isFetchingNextPage: boolean;
    nextPage: number | null;
    fetchNextPage: () => Promise<void>;
};
declare function useSlicerProductsTableQuery<const TInclude extends GetSlicerProductsParams["include"] = undefined>({ queryKey, getQueryIdentity, ...params }: UseSlicerProductsTableQueryParams<TInclude>): UsePaginatedTableQueryResult<GetSlicerProductsResponseForInclude<TInclude>["data"][number], SlicerProductsPageQuery<TInclude>, GetSlicerProductsResponseForInclude<TInclude>>;

declare const useSlicerWithdrawableFunds: ({ account, slicerAddress, currencies, chainId, enabled, refetchInterval }: {
    account?: `0x${string}`;
    slicerAddress: `0x${string}`;
    currencies: SlicerWithdrawableFundsCurrency[];
    chainId: keyof typeof fundsModuleAddress;
    enabled?: boolean;
    refetchInterval?: number;
}) => UseSlicerWithdrawableFundsResult;

type StoreMetadataAuth = GetSlicersParams extends infer TParams ? TParams extends object ? Pick<TParams, Extract<keyof TParams, "signer">> : never : never;
declare function useStoreMetadata({ slicerIds, enabled, signer }: StoreMetadataAuth & {
    slicerIds: number[] | undefined;
    enabled?: boolean;
}): _tanstack_react_query.UseQueryResult<NoInfer<(Omit<{
    acceptedCurrencies?: {
        currency?: {
            address: string;
            decimals: number;
            name: string;
            symbol: string;
        } | undefined;
        creatorFeePaid: string;
        currencyAddress: string;
        platformFeePaid: string;
        referralFeePaid: string;
        released: string;
        releasedToProtocol: string;
        releasedUsd: string;
        slicerId: number;
        totalEarned: string;
    }[] | undefined;
    appPreferences?: {
        displayFiatCurrency: string;
        enableTips: boolean;
        isDefaultDelivery: boolean;
        isDefaultOnline: boolean;
        isDefaultOnsite: boolean;
        preferredSizeUnit: "Cm" | "Inches";
        preferredWeightUnit: "G" | "Kg" | "Lbs" | "Oz";
        primaryCurrencyAddress: string | null;
        slicerId: number;
        tipsCurrencyAddress: string | null;
    } | null;
    businessDetails?: {
        physicalAddress?: {
            address: string | null;
            city: string | null;
            country: string | null;
            email: string | null;
            id: number;
            latitude: number | null;
            longitude: number | null;
            phone: string | null;
            phonePrefix: number | null;
            placeId: string | null;
            postalCode: string | null;
            state: string | null;
        } | undefined;
        name: string | null;
        physicalAddressId: number;
        slicerId: number;
        taxId: string | null;
    } | null | undefined;
    config?: {
        acceptsAllCurrencies: boolean;
        currenciesControlled: boolean;
        productsControlled: boolean;
        protocolFee: number;
        referralFeeStore: number;
        releaseTimelock: number;
        resliceAllowed: boolean;
        royaltyPercentage: number;
        royaltyReceiverAddress: string;
        slicerId: number;
        slicerVersion: number;
        storeClosed: boolean;
        transferWhileControlledAllowed: boolean;
        transferableTimelock: number;
    } | null;
    metadata: {
        externalLinks: {
            site: "Discord" | "Farcaster" | "Instagram" | "Telegram" | "Tiktok" | "Website" | "X" | "Youtube";
            slicerId: number;
            url: string;
        }[];
        bannerBackground: string | null;
        bannerImage: string | null;
        description: string | null;
        embedding: number[] | null;
        logoImage: string | null;
        name: string;
        slicerId: number;
    } | null;
    posLocations?: {
        physicalAddress?: {
            address: string | null;
            city: string | null;
            country: string | null;
            email: string | null;
            id: number;
            latitude: number | null;
            longitude: number | null;
            phone: string | null;
            phonePrefix: number | null;
            placeId: string | null;
            postalCode: string | null;
            state: string | null;
        } | undefined;
        createdAtTimestamp: string;
        id: number;
        isActive: boolean;
        name: string;
        physicalAddressId: number;
        slicerId: number;
        updatedAtTimestamp: string;
    }[] | undefined;
    productOptions?: {
        label: string | null;
        name: string;
        position: number | null;
        slicerId: number;
        values: string[] | null;
    }[] | undefined;
    productTypes?: {
        name: string;
        productTypeId: number;
        slicerId: number;
    }[] | undefined;
    address: string;
    id: number;
    minimumSlices: string;
    slices: string;
}, "acceptedCurrencies" | "appPreferences" | "businessDetails" | "config" | "posLocations" | "productOptions" | "productTypes"> & {
    acceptedCurrencies: NonNullable<_slicekit_core.GetSlicerResponse["acceptedCurrencies"]>;
} & {
    appPreferences: {
        displayFiatCurrency: string;
        enableTips: boolean;
        isDefaultDelivery: boolean;
        isDefaultOnline: boolean;
        isDefaultOnsite: boolean;
        preferredSizeUnit: "Cm" | "Inches";
        preferredWeightUnit: "G" | "Kg" | "Lbs" | "Oz";
        primaryCurrencyAddress: string | null;
        slicerId: number;
        tipsCurrencyAddress: string | null;
    } | null;
} & {
    businessDetails?: {
        physicalAddress?: {
            address: string | null;
            city: string | null;
            country: string | null;
            email: string | null;
            id: number;
            latitude: number | null;
            longitude: number | null;
            phone: string | null;
            phonePrefix: number | null;
            placeId: string | null;
            postalCode: string | null;
            state: string | null;
        } | undefined;
        name: string | null;
        physicalAddressId: number;
        slicerId: number;
        taxId: string | null;
    } | null;
} & {
    config: {
        acceptsAllCurrencies: boolean;
        currenciesControlled: boolean;
        productsControlled: boolean;
        protocolFee: number;
        referralFeeStore: number;
        releaseTimelock: number;
        resliceAllowed: boolean;
        royaltyPercentage: number;
        royaltyReceiverAddress: string;
        slicerId: number;
        slicerVersion: number;
        storeClosed: boolean;
        transferWhileControlledAllowed: boolean;
        transferableTimelock: number;
    } | null;
} & {
    posLocations: NonNullable<_slicekit_core.GetSlicerResponse["posLocations"]>;
} & {
    productOptions: NonNullable<_slicekit_core.GetSlicerResponse["productOptions"]>;
} & {
    productTypes: NonNullable<_slicekit_core.GetSlicerResponse["productTypes"]>;
})[]>, Error>;

type SliceWalletEncodedCall = {
    to: Hex;
    data: Hex;
    value?: bigint;
};
type SliceSendCallsInput = {
    account?: Hex;
    calls: SliceWalletEncodedCall[];
    capabilities?: Capabilities;
    chainId: number;
    forceAtomic?: boolean;
};
type SliceSendCallsOutput = {
    id: string;
};
type SliceSendTransactionInput = SliceWalletEncodedCall & {
    account?: Hex;
    chainId: number;
};
type SliceWaitForCallsStatusInput = {
    id: string;
    pollingInterval?: number;
    throwOnFailure?: boolean;
    timeout?: number;
};
type SliceCallsStatusReceipt = {
    transactionHash: Hex;
};
type SliceWaitForCallsStatusOutput = {
    receipts?: SliceCallsStatusReceipt[];
};
type SliceWaitForTransactionReceiptInput = {
    chainId: number;
    hash: Hex;
};
type SliceWalletCallExecutorDependencies = {
    account?: Hex;
    callsStatusPollingInterval?: number;
    callsStatusTimeout?: number;
    capabilities?: Capabilities;
    chainId: number;
    origin?: string;
    permissionExecution?: {
        onFallback?: (error: SliceAccountClientExecutionError) => Promise<void> | void;
        onSuccess?: () => Promise<void> | void;
        shouldFallback?: (error: SliceAccountClientExecutionError) => boolean;
    };
    sendCalls: (input: SliceSendCallsInput) => Promise<SliceSendCallsOutput>;
    sendTransaction: (input: SliceSendTransactionInput) => Promise<Hex>;
    smartAccountClient?: SliceAccountClient;
    supportsAtomicBatch: boolean;
    supportsPaymasterService: boolean;
    useSmartAccount?: boolean;
    waitForCallsStatus: (input: SliceWaitForCallsStatusInput) => Promise<SliceWaitForCallsStatusOutput>;
    waitForTransactionReceipt: (input: SliceWaitForTransactionReceiptInput) => Promise<SliceWalletCallReceipt>;
};
type useWalletCallsParams = {
    account?: Hex;
    callsStatusPollingInterval?: number;
    callsStatusTimeout?: number;
    capabilities?: Capabilities;
    chainId?: number;
    config?: Config;
    permissionExecution?: SliceWalletCallExecutorDependencies["permissionExecution"];
    smartAccountClient?: SliceAccountClient;
    useSmartAccount?: boolean;
};
declare const encodeSliceWalletCalls: (calls: readonly SliceWalletCall[]) => SliceAccountClientCall[];
declare const useWalletCalls: ({ account, callsStatusPollingInterval, callsStatusTimeout, capabilities, chainId: chainIdOverride, config: configOverride, permissionExecution, smartAccountClient, useSmartAccount }?: useWalletCallsParams) => {
    sendCalls: (calls: SliceWalletCall[], options?: SliceWalletCallSubmitOptions) => Promise<SliceWalletCallResult>;
    supportsAtomicBatch: boolean;
};

declare function useLoadMoreOnIntersection<TElement extends HTMLElement = HTMLDivElement>({ enabled, hasMore, isLoading, onLoadMore, requestKey, root, rootMargin, threshold }: UseLoadMoreOnIntersectionParams): {
    loadMoreRef: react.RefObject<TElement | null>;
};

declare function useLoadMoreOnScroll<TElement extends HTMLElement = HTMLElement>({ hasMore, isLoading, onLoadMore, enabled, offset, checkOnRender }: UseLoadMoreOnScrollParams): {
    scrollContainerRef: react.RefObject<TElement | null>;
    loadMoreIfNearBottom: () => void;
};

declare function usePaginatedTableQuery<TItem, TQuery extends PaginationParams, TPage extends PaginatedTablePage<TItem>>({ activeQuery, initialQuery, initialResult, queryKey, fetchPage, getQueryIdentity, normalizeQuery, onQueryTransition, activeRequestDelayMs, queryCacheKey, prefetchedPages, staleTime }: UsePaginatedTableQueryParams<TItem, TQuery, TPage>): UsePaginatedTableQueryResult<TItem, TQuery, TPage>;
declare function usePaginatedTableStateQuery<TItem, TQuery extends PaginationParams, TPage extends PaginatedTablePage<TItem>, TColumnFilters, TSorting>({ columnFilters, paginationState, sorting, setColumnFilters, setPaginationState, setSorting, tableStateToQuery, clampPageToTotal, prefetchOnPageData, ...queryParams }: UsePaginatedTableStateQueryParams<TItem, TQuery, TPage, TColumnFilters, TSorting>): UsePaginatedTableStateQueryResult<TItem, TQuery, TPage, TColumnFilters, TSorting>;

declare function usePagination<TItem>({ queryKey, initialItems, initialPagination, fetchPage, enabled, getItemKey, isComplete, mergeItems, onError, stopOnError, staleTime }: UsePaginationParams<TItem>): {
    items: TItem[];
    setItems: Dispatch<SetStateAction<TItem[]>>;
    pagination: PaginationMetadata | null;
    setPagination: Dispatch<SetStateAction<PaginationMetadata | null>>;
    error: Error | null;
    hasNextPage: boolean;
    isFetchingNextPage: boolean;
    nextPage: number | null;
    fetchNextPage: () => Promise<void>;
};

export { createPendingPagination, encodeSliceWalletCalls, resolveTablePaginationState, resolveTableState, useLoadMoreOnIntersection, useLoadMoreOnScroll, usePaginatedTableQuery, usePaginatedTableStateQuery, usePagination, usePosLocations, useProductPrice, useSlicerOrders, useSlicerOrdersTableQuery, useSlicerProducts, useSlicerProductsTableQuery, useSlicerWithdrawableFunds, useStoreMetadata, useWalletCalls };
export type { PaginatedTableCacheSnapshot, PaginatedTablePage, PaginatedTablePageDataUpdater, PaginatedTableQueryState, SliceSendWalletCalls, SliceWalletCall, SliceWalletCallLog, SliceWalletCallReceipt, SliceWalletCallResult, SliceWalletCallSubmitOptions, SlicerOrdersPageQuery, SlicerProductsPageQuery, SlicerWithdrawableCurrency, SlicerWithdrawableFundsCurrency, TablePaginationState, TablePaginationUpdater, TableStateChangeHandler, TableStateUpdater, UseLoadMoreOnIntersectionParams, UseLoadMoreOnScrollParams, UsePaginatedTableQueryFetchParams, UsePaginatedTableQueryParams, UsePaginatedTableQueryResult, UsePaginatedTableStateQueryParams, UsePaginatedTableStateQueryResult, UsePaginationParams, UsePosLocationsParams, UseSlicerOrdersParams, UseSlicerOrdersTableQueryParams, UseSlicerProductsParams, UseSlicerProductsTableQueryParams, UseSlicerWithdrawableFundsResult };