import type { Accessor } from 'solid-js';
import { AnyDataTag } from '@tanstack/query-core';
import { CancelledError } from '@tanstack/query-core';
import { CancelOptions } from '@tanstack/query-core';
import { Context } from 'solid-js';
import { ContextProviderComponent } from 'solid-js';
import { DataTag } from '@tanstack/query-core';
import { dataTagErrorSymbol } from '@tanstack/query-core';
import { dataTagSymbol } from '@tanstack/query-core';
import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
import { DefaultError } from '@tanstack/query-core';
import type { DefaultOptions as DefaultOptions_2 } from '@tanstack/query-core';
import { defaultScheduler } from '@tanstack/query-core';
import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
import { DefinedQueryObserverResult } from '@tanstack/query-core';
import { dehydrate } from '@tanstack/query-core';
import { DehydratedState } from '@tanstack/query-core';
import { DehydrateOptions } from '@tanstack/query-core';
import { DistributiveOmit } from '@tanstack/query-core';
import { Enabled } from '@tanstack/query-core';
import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
import { EnsureQueryDataOptions } from '@tanstack/query-core';
import { environmentManager } from '@tanstack/query-core';
import { experimental_streamedQuery } from '@tanstack/query-core';
import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
import { FetchNextPageOptions } from '@tanstack/query-core';
import { FetchPreviousPageOptions } from '@tanstack/query-core';
import { FetchQueryOptions } from '@tanstack/query-core';
import { FetchStatus } from '@tanstack/query-core';
import { focusManager } from '@tanstack/query-core';
import { GetNextPageParamFunction } from '@tanstack/query-core';
import { GetPreviousPageParamFunction } from '@tanstack/query-core';
import { hashKey } from '@tanstack/query-core';
import { hydrate } from '@tanstack/query-core';
import { HydrateOptions } from '@tanstack/query-core';
import { InferDataFromTag } from '@tanstack/query-core';
import { InferErrorFromTag } from '@tanstack/query-core';
import { InfiniteData } from '@tanstack/query-core';
import { InfiniteQueryObserver } from '@tanstack/query-core';
import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
import type { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_2 } from '@tanstack/query-core';
import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
import { InfiniteQueryObserverResult } from '@tanstack/query-core';
import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
import { InitialDataFunction } from '@tanstack/query-core';
import { InitialPageParam } from '@tanstack/query-core';
import { InvalidateOptions } from '@tanstack/query-core';
import { InvalidateQueryFilters } from '@tanstack/query-core';
import { isCancelledError } from '@tanstack/query-core';
import { isServer } from '@tanstack/query-core';
import type { JSX } from 'solid-js';
import { keepPreviousData } from '@tanstack/query-core';
import { ManagedTimerId } from '@tanstack/query-core';
import { matchMutation } from '@tanstack/query-core';
import { matchQuery } from '@tanstack/query-core';
import { MutateFunction } from '@tanstack/query-core';
import { MutateOptions } from '@tanstack/query-core';
import { Mutation } from '@tanstack/query-core';
import { MutationCache } from '@tanstack/query-core';
import { MutationCacheNotifyEvent } from '@tanstack/query-core';
import { MutationFilters } from '@tanstack/query-core';
import { MutationFunction } from '@tanstack/query-core';
import { MutationFunctionContext } from '@tanstack/query-core';
import { MutationKey } from '@tanstack/query-core';
import { MutationMeta } from '@tanstack/query-core';
import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
import { MutationObserverBaseResult } from '@tanstack/query-core';
import { MutationObserverErrorResult } from '@tanstack/query-core';
import { MutationObserverIdleResult } from '@tanstack/query-core';
import { MutationObserverLoadingResult } from '@tanstack/query-core';
import { MutationObserverOptions } from '@tanstack/query-core';
import { MutationObserverResult } from '@tanstack/query-core';
import { MutationObserverSuccessResult } from '@tanstack/query-core';
import { MutationOptions } from '@tanstack/query-core';
import { MutationScope } from '@tanstack/query-core';
import { MutationState } from '@tanstack/query-core';
import { MutationStatus } from '@tanstack/query-core';
import { NetworkMode } from '@tanstack/query-core';
import { NoInfer as NoInfer_2 } from '@tanstack/query-core';
import { NonUndefinedGuard } from '@tanstack/query-core';
import { noop } from '@tanstack/query-core';
import { NotifyEvent } from '@tanstack/query-core';
import { NotifyEventType } from '@tanstack/query-core';
import { notifyManager } from '@tanstack/query-core';
import { NotifyOnChangeProps } from '@tanstack/query-core';
import { OmitKeyof } from '@tanstack/query-core';
import { onlineManager } from '@tanstack/query-core';
import { Override } from '@tanstack/query-core';
import { partialMatchKey } from '@tanstack/query-core';
import { PlaceholderDataFunction } from '@tanstack/query-core';
import { QueriesObserver } from '@tanstack/query-core';
import { QueriesObserverOptions } from '@tanstack/query-core';
import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
import { Query } from '@tanstack/query-core';
import { QueryCache } from '@tanstack/query-core';
import { QueryCacheNotifyEvent } from '@tanstack/query-core';
import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
import type { QueryClientConfig as QueryClientConfig_2 } from '@tanstack/query-core';
import { QueryFilters } from '@tanstack/query-core';
import { QueryFunction } from '@tanstack/query-core';
import { QueryFunctionContext } from '@tanstack/query-core';
import { QueryKey } from '@tanstack/query-core';
import { QueryKeyHashFunction } from '@tanstack/query-core';
import { QueryMeta } from '@tanstack/query-core';
import { QueryObserver } from '@tanstack/query-core';
import { QueryObserverBaseResult } from '@tanstack/query-core';
import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
import { QueryObserverLoadingResult } from '@tanstack/query-core';
import type { QueryObserverOptions as QueryObserverOptions_2 } from '@tanstack/query-core';
import { QueryObserverPendingResult } from '@tanstack/query-core';
import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
import { QueryObserverResult } from '@tanstack/query-core';
import { QueryObserverSuccessResult } from '@tanstack/query-core';
import { QueryOptions } from '@tanstack/query-core';
import { QueryPersister } from '@tanstack/query-core';
import { QueryState } from '@tanstack/query-core';
import { QueryStatus } from '@tanstack/query-core';
import { RefetchOptions } from '@tanstack/query-core';
import { RefetchQueryFilters } from '@tanstack/query-core';
import { Register } from '@tanstack/query-core';
import { replaceEqualDeep } from '@tanstack/query-core';
import { ResetOptions } from '@tanstack/query-core';
import { ResultOptions } from '@tanstack/query-core';
import { SetDataOptions } from '@tanstack/query-core';
import { shouldThrowError } from '@tanstack/query-core';
import { SkipToken } from '@tanstack/query-core';
import { skipToken } from '@tanstack/query-core';
import { StaleTime } from '@tanstack/query-core';
import { StaleTimeFunction } from '@tanstack/query-core';
import { ThrowOnError } from '@tanstack/query-core';
import { TimeoutCallback } from '@tanstack/query-core';
import { timeoutManager } from '@tanstack/query-core';
import { TimeoutProvider } from '@tanstack/query-core';
import { UnsetMarker } from '@tanstack/query-core';
import { unsetMarker } from '@tanstack/query-core';
import { Updater } from '@tanstack/query-core';
import { WithRequired } from '@tanstack/query-core';

export { AnyDataTag }

export { CancelledError }

export { CancelOptions }

export declare const createInfiniteQuery: typeof useInfiniteQuery;

export declare const createMutation: typeof useMutation;

export declare const createQueries: typeof useQueries;

export declare const createQuery: typeof useQuery;

export { DataTag }

export { dataTagErrorSymbol }

export { dataTagSymbol }

export { DefaultedInfiniteQueryObserverOptions }

export { DefaultedQueryObserverOptions }

export { DefaultError }

declare interface DefaultOptions<TError = DefaultError> extends DefaultOptions_2<TError> {
    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
}
export { DefaultOptions }
export { DefaultOptions as DefaultOptions_alias_1 }

export { defaultScheduler }

export { defaultShouldDehydrateMutation }

export { defaultShouldDehydrateQuery }

export { DefinedInfiniteQueryObserverResult }

declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
}>;
export { DefinedInitialDataInfiniteOptions }
export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }

declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
    initialData: TQueryFnData | (() => TQueryFnData);
}>;
export { DefinedInitialDataOptions }
export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }

export { DefinedQueryObserverResult }

declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
export { DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult }
export { DefinedUseBaseQueryResult }
export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }

declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
export { DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult }
export { DefinedUseInfiniteQueryResult }
export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }

declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
export { DefinedUseQueryResult as DefinedCreateQueryResult }
export { DefinedUseQueryResult }
export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }

export { dehydrate }

export { DehydratedState }

export { DehydrateOptions }

export { DistributiveOmit }

export { Enabled }

export { EnsureInfiniteQueryDataOptions }

export { EnsureQueryDataOptions }

export { environmentManager }

export { experimental_streamedQuery }

export { FetchInfiniteQueryOptions }

export { FetchNextPageOptions }

export { FetchPreviousPageOptions }

export { FetchQueryOptions }

export { FetchStatus }

export { focusManager }

export { GetNextPageParamFunction }

declare type GetOptions<T> = T extends {
    queryFnData: infer TQueryFnData;
    error?: infer TError;
    data: infer TData;
} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
    queryFnData: infer TQueryFnData;
    error?: infer TError;
} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
    data: infer TData;
    error?: infer TError;
} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
    select?: (data: any) => infer TData;
    throwOnError?: ThrowOnError<any, infer TError, any, any>;
} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;

export { GetPreviousPageParamFunction }

declare type GetResults<T> = T extends {
    queryFnData: any;
    error?: infer TError;
    data: infer TData;
} ? UseQueryResult<TData, TError> : T extends {
    queryFnData: infer TQueryFnData;
    error?: infer TError;
} ? UseQueryResult<TQueryFnData, TError> : T extends {
    data: infer TData;
    error?: infer TError;
} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
    select?: (data: any) => infer TData;
    throwOnError?: ThrowOnError<any, infer TError, any, any>;
} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;

export { hashKey }

export { hydrate }

export { HydrateOptions }

export { InferDataFromTag }

export { InferErrorFromTag }

export { InfiniteData }

export { InfiniteQueryObserver }

export { InfiniteQueryObserverBaseResult }

export { InfiniteQueryObserverLoadingErrorResult }

export { InfiniteQueryObserverLoadingResult }

declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'structuralSharing'> {
    /**
     * Set this to a reconciliation key to enable reconciliation between query results.
     * Set this to `false` to disable reconciliation between query results.
     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
     * Defaults reconciliation to false.
     */
    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
}
export { InfiniteQueryObserverOptions }
export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }

export { InfiniteQueryObserverPendingResult }

export { InfiniteQueryObserverPlaceholderResult }

export { InfiniteQueryObserverRefetchErrorResult }

export { InfiniteQueryObserverResult }

export { InfiniteQueryObserverSuccessResult }

declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
};

declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
};
export { infiniteQueryOptions }
export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }

export { InfiniteQueryPageParamsOptions }

export { InitialDataFunction }

export { InitialPageParam }

export { InvalidateOptions }

export { InvalidateQueryFilters }

export { isCancelledError }

declare const IsRestoringProvider: ContextProviderComponent<Accessor<boolean>>;
export { IsRestoringProvider }
export { IsRestoringProvider as IsRestoringProvider_alias_1 }

export { isServer }

export { keepPreviousData }

export { ManagedTimerId }

export { matchMutation }

export { matchQuery }

declare type MAXIMUM_DEPTH = 20;

export { MutateFunction }

export { MutateOptions }

export { Mutation }

export { MutationCache }

export { MutationCacheNotifyEvent }

export { MutationFilters }

export { MutationFunction }

export { MutationFunctionContext }

export { MutationKey }

export { MutationMeta }

export { MutationObserver_2 as MutationObserver }

export { MutationObserverBaseResult }

export { MutationObserverErrorResult }

export { MutationObserverIdleResult }

export { MutationObserverLoadingResult }

export { MutationObserverOptions }

export { MutationObserverResult }

export { MutationObserverSuccessResult }

export { MutationOptions }

declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;

declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
export { mutationOptions }
export { mutationOptions as mutationOptions_alias_1 }

export { MutationScope }

export { MutationState }

declare type MutationStateOptions<TResult = MutationState> = {
    filters?: MutationFilters;
    select?: (mutation: Mutation) => TResult;
};

export { MutationStatus }

export { NetworkMode }

export { NoInfer_2 as NoInfer }

export { NonUndefinedGuard }

export { noop }

export { NotifyEvent }

export { NotifyEventType }

export { notifyManager }

export { NotifyOnChangeProps }

export { OmitKeyof }

export { onlineManager }

export { Override }

export { partialMatchKey }

export { PlaceholderDataFunction }

export { QueriesObserver }

export { QueriesObserverOptions }

/**
 * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
 */
declare type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
...Tail
], [
...TResult,
GetOptions<Head>
], [
...TDepth,
1
]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;

export { QueriesPlaceholderDataFunction }

/**
 * QueriesResults reducer recursively maps type param to results
 */
declare type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
...Tail
], [
...TResult,
GetResults<Head>
], [
...TDepth,
1
]> : {
    [K in keyof T]: GetResults<T[K]>;
};

export { Query }

export { QueryCache }

export { QueryCacheNotifyEvent }

declare class QueryClient extends QueryClient_2 {
    constructor(config?: QueryClientConfig);
}
export { QueryClient }
export { QueryClient as QueryClient_alias_1 }

declare interface QueryClientConfig extends QueryClientConfig_2 {
    defaultOptions?: DefaultOptions;
}
export { QueryClientConfig }
export { QueryClientConfig as QueryClientConfig_alias_1 }

declare const QueryClientContext: Context<(() => QueryClient) | undefined>;
export { QueryClientContext }
export { QueryClientContext as QueryClientContext_alias_1 }

declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
export { QueryClientProvider }
export { QueryClientProvider as QueryClientProvider_alias_1 }

declare type QueryClientProviderProps = {
    client: QueryClient;
    children?: JSX.Element;
};
export { QueryClientProviderProps }
export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }

export { QueryFilters }

export { QueryFunction }

export { QueryFunctionContext }

export { QueryKey }

export { QueryKeyHashFunction }

export { QueryMeta }

export { QueryObserver }

export { QueryObserverBaseResult }

export { QueryObserverLoadingErrorResult }

export { QueryObserverLoadingResult }

declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions_2<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
    /**
     * Set this to a reconciliation key to enable reconciliation between query results.
     * Set this to `false` to disable reconciliation between query results.
     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
     * Defaults reconciliation to false.
     */
    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
}
export { QueryObserverOptions }
export { QueryObserverOptions as QueryObserverOptions_alias_1 }

export { QueryObserverPendingResult }

export { QueryObserverPlaceholderResult }

export { QueryObserverRefetchErrorResult }

export { QueryObserverResult }

export { QueryObserverSuccessResult }

export { QueryOptions }

declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
};

declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
};
export { queryOptions }
export { queryOptions as queryOptions_alias_1 }

export { QueryPersister }

export { QueryState }

export { QueryStatus }

export { RefetchOptions }

export { RefetchQueryFilters }

export { Register }

export { replaceEqualDeep }

export { ResetOptions }

export { ResultOptions }

export { SetDataOptions }

export { shouldThrowError }

export { SkipToken }

export { skipToken }

declare type SkipTokenForUseQueries = symbol;

declare interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
    queryKey: TQueryKey;
    /**
     * Only applicable while rendering queries on the server with streaming.
     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
     * This can be useful to avoid sending a loading state to the client before the query has resolved.
     * Defaults to `false`.
     */
    deferStream?: boolean;
    /**
     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
     * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
     * Setting `suspense` to `false` will be a no-op.
     */
    suspense?: boolean;
}
export { SolidInfiniteQueryOptions }
export { SolidInfiniteQueryOptions as SolidInfiniteQueryOptions_alias_1 }

declare interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
}
export { SolidMutationOptions }
export { SolidMutationOptions as SolidMutationOptions_alias_1 }

declare interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
}
export { SolidQueryOptions }
export { SolidQueryOptions as SolidQueryOptions_alias_1 }

export { StaleTime }

export { StaleTimeFunction }

export { ThrowOnError }

export { TimeoutCallback }

export { timeoutManager }

export { TimeoutProvider }

declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
    initialData?: undefined;
}>;
export { UndefinedInitialDataInfiniteOptions }
export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }

declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
    initialData?: undefined;
}>;
export { UndefinedInitialDataOptions }
export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }

export { UnsetMarker }

export { unsetMarker }

export { Updater }

declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
    mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
}> & {
    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
};
export { UseBaseMutationResult as CreateBaseMutationResult }
export { UseBaseMutationResult }
export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }

export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): QueryObserverResult<TData, TError>;

declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
    /**
     * Only applicable while rendering queries on the server with streaming.
     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
     * This can be useful to avoid sending a loading state to the client before the query has resolved.
     * Defaults to `false`.
     */
    deferStream?: boolean;
    /**
     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
     * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
     * Setting `suspense` to `false` will be a no-op.
     */
    suspense?: boolean;
}
export { UseBaseQueryOptions as CreateBaseQueryOptions }
export { UseBaseQueryOptions }
export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }

declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
export { UseBaseQueryResult as CreateBaseQueryResult }
export { UseBaseQueryResult }
export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }

declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;

declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
export { useInfiniteQuery }
export { useInfiniteQuery as useInfiniteQuery_alias_1 }

declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
export { UseInfiniteQueryOptions as CreateInfiniteQueryOptions }
export { UseInfiniteQueryOptions }
export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }

declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
export { UseInfiniteQueryResult as CreateInfiniteQueryResult }
export { UseInfiniteQueryResult }
export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }

declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
export { useIsFetching as createIsFetching }
export { useIsFetching }
export { useIsFetching as useIsFetching_alias_1 }

declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
export { useIsMutating as createIsMutating }
export { useIsMutating }
export { useIsMutating as useIsMutating_alias_1 }

declare const useIsRestoring: () => Accessor<boolean>;
export { useIsRestoring }
export { useIsRestoring as useIsRestoring_alias_1 }

declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
export { UseMutateAsyncFunction as CreateMutateAsyncFunction }
export { UseMutateAsyncFunction }
export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }

declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
export { UseMutateFunction as CreateMutateFunction }
export { UseMutateFunction }
export { UseMutateFunction as UseMutateFunction_alias_1 }

declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
export { useMutation }
export { useMutation as useMutation_alias_1 }

declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>;
export { UseMutationOptions as CreateMutationOptions }
export { UseMutationOptions }
export { UseMutationOptions as UseMutationOptions_alias_1 }

declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
export { UseMutationResult as CreateMutationResult }
export { UseMutationResult }
export { UseMutationResult as UseMutationResult_alias_1 }

declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
export { useMutationState as createMutationState }
export { useMutationState }
export { useMutationState as useMutationState_alias_1 }

declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
    queries: readonly [...QueriesOptions<T>] | readonly [...{
        [K in keyof T]: GetOptions<T[K]>;
    }];
    combine?: (result: QueriesResults<T>) => TCombinedResult;
}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
export { useQueries }
export { useQueries as useQueries_alias_1 }

declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;

declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
export { useQuery }
export { useQuery as useQuery_alias_1 }

declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
export { useQueryClient }
export { useQueryClient as useQueryClient_alias_1 }

declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
export { UseQueryOptions as CreateQueryOptions }
export { UseQueryOptions }
export { UseQueryOptions as UseQueryOptions_alias_1 }

declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
    /**
     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
     * The `data` property on useQueries is a plain object and not a SolidJS Resource.
     * It will not suspend when the data is loading.
     * Setting `suspense` to `true` will be a no-op.
     */
    suspense?: boolean;
};

declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
export { UseQueryResult as CreateQueryResult }
export { UseQueryResult }
export { UseQueryResult as UseQueryResult_alias_1 }

export { WithRequired }

export { }