@tanstack/vue-query 5.94.4 → 5.95.0

package/build/legacy/_tsup-dts-rollup.d.cts

@@ -0,0 +1,855 @@
+import { AnyDataTag } from '@tanstack/query-core';
+import { CancelledError } from '@tanstack/query-core';
+import { CancelOptions } from '@tanstack/query-core';
+import type { ComputedRef } from 'vue-demi';
+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 { DefaultOptions } 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 { InfiniteQueryObserverOptions } 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 { keepPreviousData } from '@tanstack/query-core';
+import { ManagedTimerId } from '@tanstack/query-core';
+import { matchMutation } from '@tanstack/query-core';
+import { matchQuery } from '@tanstack/query-core';
+import { Mock } from 'vitest';
+import { MutateFunction } from '@tanstack/query-core';
+import { MutateOptions } from '@tanstack/query-core';
+import { Mutation } from '@tanstack/query-core';
+import { MutationCache as MutationCache_2 } from '@tanstack/query-core';
+import { MutationCacheNotifyEvent } from '@tanstack/query-core';
+import type { MutationFilters as MutationFilters_2 } 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 { Options } from 'tsup';
+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 as QueryCache_2 } from '@tanstack/query-core';
+import { QueryCacheNotifyEvent } from '@tanstack/query-core';
+import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
+import { QueryClientConfig } from '@tanstack/query-core';
+import type { QueryFilters as QueryFilters_2 } 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 { QueryObserverOptions } 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 type { Ref } from 'vue-demi';
+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 type { ToRefs } from 'vue-demi';
+import { UnsetMarker } from '@tanstack/query-core';
+import { unsetMarker } from '@tanstack/query-core';
+import type { UnwrapRef } from 'vue-demi';
+import { Updater } from '@tanstack/query-core';
+import { UserConfig } from 'vite';
+import { WithRequired } from '@tanstack/query-core';
+
+export { AnyDataTag }
+
+export { CancelledError }
+
+export { CancelOptions }
+
+declare interface ClientOptions extends CommonOptions {
+    queryClient?: QueryClient;
+}
+
+declare type ClientPersister = (client: QueryClient) => [() => void, Promise<void>];
+
+export declare function cloneDeep<T>(value: MaybeRefDeep<T>, customize?: (val: MaybeRefDeep<T>, key: string, level: number) => T | undefined): T;
+
+export declare function cloneDeepUnref<T>(obj: MaybeRefDeep<T>, unrefGetters?: boolean): T;
+
+declare interface CommonOptions {
+    enableDevtoolsV6Plugin?: boolean;
+    queryClientKey?: string;
+    clientPersister?: ClientPersister;
+    clientPersisterOnSuccess?: (client: QueryClient) => void;
+}
+
+declare interface ConfigOptions extends CommonOptions {
+    queryClientConfig?: QueryClientConfig_alias_1;
+}
+
+export { DataTag }
+
+export { dataTagErrorSymbol }
+
+export { dataTagSymbol }
+
+export declare type DeepUnwrapRef<T> = T extends UnwrapLeaf ? T : T extends Ref<infer U> ? DeepUnwrapRef<U> : T extends {} ? {
+    [Property in keyof T]: DeepUnwrapRef<T[Property]>;
+} : UnwrapRef<T>;
+
+export declare const default_alias: any[];
+
+export declare const default_alias_1: any[];
+
+export declare const default_alias_2: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_3: UserConfig;
+
+export { DefaultedInfiniteQueryObserverOptions }
+
+export { DefaultedQueryObserverOptions }
+
+export { DefaultError }
+
+export { DefaultOptions }
+
+export declare interface DefaultOptions_alias_1<TError = DefaultError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'> & ShallowOption;
+    mutations?: MutationObserverOptions<unknown, TError, unknown, unknown> & ShallowOption;
+    hydrate?: HydrateOptions['defaultOptions'];
+    dehydrate?: DehydrateOptions;
+}
+
+export { defaultScheduler }
+
+export { defaultShouldDehydrateMutation }
+
+export { defaultShouldDehydrateQuery }
+
+export { DefinedInfiniteQueryObserverResult }
+
+declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
+};
+export { DefinedInitialDataInfiniteOptions }
+export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }
+
+declare type DefinedInitialQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+};
+export { DefinedInitialQueryOptions }
+export { DefinedInitialQueryOptions as DefinedInitialQueryOptions_alias_1 }
+
+export { DefinedQueryObserverResult }
+
+export { dehydrate }
+
+export { DehydratedState }
+
+export { DehydrateOptions }
+
+export { DistributiveOmit }
+
+export { Enabled }
+
+export { EnsureInfiniteQueryDataOptions }
+
+export { EnsureQueryDataOptions }
+
+export { environmentManager }
+
+export declare type Equal<TTargetA, TTargetB> = (<T>() => T extends TTargetA ? 1 : 2) extends <T>() => T extends TTargetB ? 1 : 2 ? true : false;
+
+export { experimental_streamedQuery }
+
+export { FetchInfiniteQueryOptions }
+
+export { FetchNextPageOptions }
+
+export { FetchPreviousPageOptions }
+
+export { FetchQueryOptions }
+
+export { FetchStatus }
+
+export { focusManager }
+
+export declare function getClientKey(key?: string): string;
+
+declare type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
+    initialData?: infer TInitialData;
+} ? unknown extends TInitialData ? QueryObserverResult<TData, TError> : TInitialData extends TData ? DefinedQueryObserverResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? QueryObserverResult<TData, TError> : TInitialDataResult extends TData ? DefinedQueryObserverResult<TData, TError> : QueryObserverResult<TData, TError> : QueryObserverResult<TData, TError> : QueryObserverResult<TData, TError>;
+
+export { GetNextPageParamFunction }
+
+export { GetPreviousPageParamFunction }
+
+export declare function getQueryState(query: Query): QueryState_2;
+
+export declare function getQueryStateLabel(query: Query): string;
+
+export declare function getQueryStatusBg(query: Query): number;
+
+export declare function getQueryStatusFg(query: Query): number;
+
+declare type GetUseQueryOptionsForUseQueries<T> = T extends UseQueryOptions ? DeepUnwrapRef<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> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseQueryOptionsForUseQueries;
+
+declare type GetUseQueryResult<T> = T extends UseQueryOptions<infer TQueryFnData, infer TError, infer TData, any, any> ? GetDefinedOrUndefinedQueryResult<T, undefined extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, unknown extends TError ? DefaultError : TError> : QueryObserverResult;
+
+export { hashKey }
+
+export { hydrate }
+
+export { HydrateOptions }
+
+export { InferDataFromTag }
+
+export { InferErrorFromTag }
+
+export { InfiniteData }
+
+export { InfiniteQueryObserver }
+
+export { InfiniteQueryObserverBaseResult }
+
+export { InfiniteQueryObserverLoadingErrorResult }
+
+export { InfiniteQueryObserverLoadingResult }
+
+export { InfiniteQueryObserverOptions }
+
+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: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+export { infiniteQueryOptions }
+export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }
+
+export { InfiniteQueryPageParamsOptions }
+
+export { InitialDataFunction }
+
+export { InitialPageParam }
+
+export { InvalidateOptions }
+
+export { InvalidateQueryFilters }
+
+export { isCancelledError }
+
+export { isServer }
+
+export { keepPreviousData }
+
+/**
+ * @param {Object} opts - Options for building configurations.
+ * @param {string[]} opts.entry - The entry array.
+ * @returns {import('tsup').Options}
+ */
+export declare function legacyConfig(opts: {
+    entry: string[];
+}): Options;
+
+export { ManagedTimerId }
+
+export { matchMutation }
+
+export { matchQuery }
+
+declare type MAXIMUM_DEPTH = 20;
+
+export declare type MaybeRef<T> = Ref<T> | ComputedRef<T> | T;
+
+export declare type MaybeRefDeep<T> = MaybeRef<T extends Function ? T : T extends object ? {
+    [Property in keyof T]: MaybeRefDeep<T[Property]>;
+} : T>;
+
+export declare type MaybeRefOrGetter<T> = MaybeRef<T> | (() => T);
+
+/**
+ * @param {Object} opts - Options for building configurations.
+ * @param {string[]} opts.entry - The entry array.
+ * @returns {import('tsup').Options}
+ */
+export declare function modernConfig(opts: {
+    entry: string[];
+}): Options;
+
+export { MutateFunction }
+
+export { MutateOptions }
+
+declare type MutateSyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...options: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+
+export { Mutation }
+
+declare class MutationCache extends MutationCache_2 {
+    find<TData = unknown, TError = DefaultError, TVariables = any, TOnMutateResult = unknown>(filters: MaybeRefDeep<MutationFilters_2>): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined;
+    findAll(filters?: MaybeRefDeep<MutationFilters_2>): Array<Mutation>;
+}
+export { MutationCache }
+export { MutationCache as MutationCache_alias_1 }
+
+export { MutationCacheNotifyEvent }
+
+declare type MutationFilters = MaybeRefDeep<MutationFilters_2>;
+export { MutationFilters }
+export { MutationFilters as MutationFilters_alias_1 }
+
+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 type MutationResult<TData, TError, TVariables, TOnMutateResult> = DistributiveOmit<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, 'mutate' | 'reset'>;
+
+export { MutationScope }
+
+export { MutationState }
+
+declare type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+export { MutationStateOptions }
+export { MutationStateOptions as MutationStateOptions_alias_1 }
+
+export { MutationStatus }
+
+export { NetworkMode }
+
+export { NoInfer_2 as NoInfer }
+
+export { NonUndefinedGuard }
+
+export { noop }
+
+export { NotifyEvent }
+
+export { NotifyEventType }
+
+export { notifyManager }
+
+export { NotifyOnChangeProps }
+
+export declare type NoUnknown<T> = Equal<unknown, T> extends true ? never : T;
+
+export { OmitKeyof }
+
+export { onlineManager }
+
+export { Override }
+
+export { partialMatchKey }
+
+export { PlaceholderDataFunction }
+
+declare type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+
+export { QueriesObserver }
+
+export { QueriesObserverOptions }
+
+export { QueriesPlaceholderDataFunction }
+
+export { Query }
+
+declare class QueryCache extends QueryCache_2 {
+    find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: MaybeRefDeep<WithRequired<QueryFilters_2, 'queryKey'>>): Query<TQueryFnData, TError, TData> | undefined;
+    findAll(filters?: MaybeRefDeep<QueryFilters_2>): Array<Query>;
+}
+export { QueryCache }
+export { QueryCache as QueryCache_alias_1 }
+
+export { QueryCacheNotifyEvent }
+
+declare class QueryClient extends QueryClient_2 {
+    constructor(config?: QueryClientConfig_alias_1);
+    isRestoring?: Ref<boolean>;
+    isFetching(filters?: MaybeRefDeep<QueryFilters_2>): number;
+    isMutating(filters?: MaybeRefDeep<MutationFilters_2>): number;
+    getQueryData<TData = unknown, TTaggedQueryKey extends QueryKey = QueryKey>(queryKey: TTaggedQueryKey): InferDataFromTag<TData, TTaggedQueryKey> | undefined;
+    getQueryData<TData = unknown>(queryKey: MaybeRefDeep<QueryKey>): TData | undefined;
+    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefDeep<EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>>): Promise<TData>;
+    getQueriesData<TData = unknown>(filters: MaybeRefDeep<QueryFilters_2>): Array<[QueryKey, TData | undefined]>;
+    setQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey, updater: Updater<NoInfer_2<TInferredQueryFnData> | undefined, NoInfer_2<TInferredQueryFnData> | undefined>, options?: MaybeRefDeep<SetDataOptions>): NoInfer_2<TInferredQueryFnData> | undefined;
+    setQueryData<TQueryFnData, TData = NoUnknown<TQueryFnData>>(queryKey: MaybeRefDeep<QueryKey>, updater: Updater<NoInfer_2<TData> | undefined, NoInfer_2<TData> | undefined>, options?: MaybeRefDeep<SetDataOptions>): NoInfer_2<TData> | undefined;
+    setQueriesData<TData>(filters: MaybeRefDeep<QueryFilters_2>, updater: Updater<TData | undefined, TData | undefined>, options?: MaybeRefDeep<SetDataOptions>): Array<[QueryKey, TData | undefined]>;
+    getQueryState<TData = unknown, TError = DefaultError>(queryKey: MaybeRefDeep<QueryKey>): QueryState<TData, TError> | undefined;
+    removeQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: QueryFilters_2<TTaggedQueryKey>): void;
+    resetQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: QueryFilters_2<TTaggedQueryKey>, options?: MaybeRefDeep<ResetOptions>): Promise<void>;
+    cancelQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: QueryFilters_2<TTaggedQueryKey>, options?: MaybeRefDeep<CancelOptions>): Promise<void>;
+    invalidateQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: InvalidateQueryFilters<TTaggedQueryKey>, options?: MaybeRefDeep<InvalidateOptions>): Promise<void>;
+    refetchQueries<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(filters?: RefetchQueryFilters<TTaggedQueryKey>, options?: MaybeRefDeep<RefetchOptions>): Promise<void>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): Promise<TData>;
+    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>>): Promise<void>;
+    fetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
+    fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefDeep<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): Promise<InfiniteData<TData, TPageParam>>;
+    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
+    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefDeep<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): Promise<void>;
+    setDefaultOptions(options: MaybeRefDeep<DefaultOptions>): void;
+    setQueryDefaults<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData>(queryKey: MaybeRefDeep<QueryKey>, options: MaybeRefDeep<Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryData>, 'queryKey'>>): void;
+    getQueryDefaults(queryKey: MaybeRefDeep<QueryKey>): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'>;
+    setMutationDefaults<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(mutationKey: MaybeRefDeep<MutationKey>, options: MaybeRefDeep<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>>): void;
+    getMutationDefaults(mutationKey: MaybeRefDeep<MutationKey>): MutationObserverOptions<any, any, any, any>;
+}
+export { QueryClient }
+export { QueryClient as QueryClient_alias_1 }
+
+export { QueryClientConfig }
+
+export declare interface QueryClientConfig_alias_1 {
+    queryCache?: QueryCache_2;
+    mutationCache?: MutationCache_2;
+    defaultOptions?: DefaultOptions_alias_1;
+}
+
+declare type QueryFilters = MaybeRefDeep<QueryFilters_2> | (() => MaybeRefDeep<QueryFilters_2>);
+export { QueryFilters }
+export { QueryFilters as QueryFilters_alias_1 }
+
+export { QueryFunction }
+
+export { QueryFunctionContext }
+
+export { QueryKey }
+
+export { QueryKeyHashFunction }
+
+export { QueryMeta }
+
+export { QueryObserver }
+
+export { QueryObserverBaseResult }
+
+export { QueryObserverLoadingErrorResult }
+
+export { QueryObserverLoadingResult }
+
+export { QueryObserverOptions }
+
+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: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+export { queryOptions }
+export { queryOptions as queryOptions_alias_1 }
+
+export { QueryPersister }
+
+export { QueryState }
+
+declare enum QueryState_2 {
+    Fetching = 0,
+    Fresh = 1,
+    Stale = 2,
+    Inactive = 3,
+    Paused = 4
+}
+
+export { QueryStatus }
+
+export { RefetchOptions }
+
+export { RefetchQueryFilters }
+
+export { Register }
+
+export { replaceEqualDeep }
+
+export { ResetOptions }
+
+export { ResultOptions }
+
+export { SetDataOptions }
+
+export declare function setupDevtools(app: any, queryClient: QueryClient): void;
+
+export declare type ShallowOption = {
+    /**
+     * Return data in a shallow ref object (it is `false` by default). It can be set to `true` to return data in a shallow ref object, which can improve performance if your data does not need to be deeply reactive.
+     */
+    shallow?: boolean;
+};
+
+export { shouldThrowError }
+
+export { SkipToken }
+
+export { skipToken }
+
+declare type SkipTokenForUseQueries = symbol;
+
+declare type SortFn = (a: Query, b: Query) => number;
+
+export declare const sortFns: Record<string, SortFn>;
+
+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> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData?: undefined;
+};
+export { UndefinedInitialDataInfiniteOptions }
+export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }
+
+declare type UndefinedInitialQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
+};
+export { UndefinedInitialQueryOptions }
+export { UndefinedInitialQueryOptions as UndefinedInitialQueryOptions_alias_1 }
+
+export { UnsetMarker }
+
+export { unsetMarker }
+
+declare type UnwrapLeaf = Primitive | Function | Date | Error | RegExp | Map<any, any> | WeakMap<any, any> | Set<any> | WeakSet<any>;
+
+export { Updater }
+
+export declare function updateState(state: Record<string, any>, update: Record<string, any>): void;
+
+export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey, TPageParam>(Observer: typeof QueryObserver, options: MaybeRefOrGetter<UseQueryOptionsGeneric<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseBaseQueryReturnType<TData, TError>;
+
+export declare const useBaseQuery_alias_1: Mock<typeof UseBaseQueryModule.useBaseQuery>;
+
+declare namespace UseBaseQueryModule {
+    export {
+        useBaseQuery,
+        UseBaseQueryReturnType
+    }
+}
+
+export declare type UseBaseQueryReturnType<TData, TError, TResult = QueryObserverResult<TData, TError>> = {
+    [K in keyof TResult]: K extends 'fetchNextPage' | 'fetchPreviousPage' | 'refetch' ? TResult[K] : Ref<Readonly<TResult>[K]>;
+} & {
+    suspense: () => Promise<TResult>;
+};
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefOrGetter<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseInfiniteQueryReturnType<TData, TError>;
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefOrGetter<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseInfiniteQueryReturnType<TData, TError>;
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: MaybeRefOrGetter<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): UseInfiniteQueryReturnType<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> = MaybeRef<{
+    [Property in keyof InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>]: Property extends 'enabled' ? MaybeRefOrGetter<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, DeepUnwrapRef<TQueryKey>, TPageParam>[Property]> : MaybeRefDeep<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, DeepUnwrapRef<TQueryKey>, TPageParam>[Property]>;
+} & ShallowOption>;
+export { UseInfiniteQueryOptions }
+export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
+
+declare type UseInfiniteQueryReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError, InfiniteQueryObserverResult<TData, TError>>;
+export { UseInfiniteQueryReturnType }
+export { UseInfiniteQueryReturnType as UseInfiniteQueryReturnType_alias_1 }
+
+declare function useIsFetching(fetchingFilters?: QueryFilters, queryClient?: QueryClient): Ref<number>;
+export { useIsFetching }
+export { useIsFetching as useIsFetching_alias_1 }
+
+declare function useIsMutating(filters?: MutationFilters | (() => MutationFilters), queryClient?: QueryClient): Ref<number>;
+export { useIsMutating }
+export { useIsMutating as useIsMutating_alias_1 }
+
+declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(mutationOptions: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationReturnType<TData, TError, TVariables, TOnMutateResult>;
+export { useMutation }
+export { useMutation as useMutation_alias_1 }
+
+declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MaybeRefDeep<UseMutationOptionsBase<TData, TError, TVariables, TOnMutateResult>> | (() => MaybeRefDeep<UseMutationOptionsBase<TData, TError, TVariables, TOnMutateResult>>);
+export { UseMutationOptions }
+export { UseMutationOptions as UseMutationOptions_alias_1 }
+
+declare type UseMutationOptionsBase<TData, TError, TVariables, TOnMutateResult> = OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> & ShallowOption;
+
+declare type UseMutationReturnType<TData, TError, TVariables, TOnMutateResult, TResult = MutationResult<TData, TError, TVariables, TOnMutateResult>> = ToRefs<Readonly<TResult>> & {
+    mutate: MutateSyncFunction<TData, TError, TVariables, TOnMutateResult>;
+    mutateAsync: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+    reset: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>['reset'];
+};
+export { UseMutationReturnType }
+export { UseMutationReturnType as UseMutationReturnType_alias_1 }
+
+declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult> | (() => MutationStateOptions<TResult>), queryClient?: QueryClient): Readonly<Ref<Array<TResult>>>;
+export { useMutationState }
+export { useMutationState as useMutationState_alias_1 }
+
+declare function useQueries<T extends Array<any>, TCombinedResult = UseQueriesResults<T>>({ queries, ...options }: ShallowOption & {
+    queries: (() => MaybeRefDeep<UseQueriesOptionsArg<T>>) | MaybeRefDeep<UseQueriesOptionsArg<T>> | MaybeRefDeep<readonly [
+    ...{
+        [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
+    }
+    ]>;
+    combine?: (result: UseQueriesResults<T>) => TCombinedResult;
+}, queryClient?: QueryClient): Readonly<Ref<TCombinedResult>>;
+export { useQueries }
+export { useQueries as useQueries_alias_1 }
+
+/**
+ * UseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+declare type UseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? UseQueriesOptions<[
+...Tails
+], [
+...TResults,
+GetUseQueryOptionsForUseQueries<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 { UseQueriesOptions }
+export { UseQueriesOptions as UseQueriesOptions_alias_1 }
+
+declare type UseQueriesOptionsArg<T extends Array<any>> = readonly [
+...UseQueriesOptions<T>
+];
+
+/**
+ * UseQueriesResults reducer recursively maps type param to results
+ */
+declare type UseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? UseQueriesResults<[
+...Tails
+], [
+...TResults,
+GetUseQueryResult<Head>
+], [
+...TDepth,
+1
+]> : {
+    [K in keyof T]: GetUseQueryResult<T[K]>;
+};
+export { UseQueriesResults }
+export { UseQueriesResults as UseQueriesResults_alias_1 }
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryDefinedReturnType<TData, TError>;
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: MaybeRefOrGetter<UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
+export { useQuery }
+export { useQuery as useQuery_alias_1 }
+
+declare function useQueryClient(id?: string): QueryClient;
+export { useQueryClient }
+export { useQueryClient as useQueryClient_alias_1 }
+
+export declare const useQueryClient_alias_2: Mock<() => QueryClient>;
+
+declare type UseQueryDefinedReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError, DefinedQueryObserverResult<TData, TError>>;
+export { UseQueryDefinedReturnType }
+export { UseQueryDefinedReturnType as UseQueryDefinedReturnType_alias_1 }
+
+declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = MaybeRef<{
+    [Property in keyof QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>]: Property extends 'enabled' ? MaybeRefOrGetter<boolean | undefined> | (() => Enabled<TQueryFnData, TError, TQueryData, DeepUnwrapRef<TQueryKey>>) : MaybeRefDeep<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, DeepUnwrapRef<TQueryKey>>[Property]>;
+} & ShallowOption>;
+export { UseQueryOptions }
+export { UseQueryOptions as UseQueryOptions_alias_1 }
+
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>;
+
+declare type UseQueryOptionsGeneric<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> | UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>;
+
+declare type UseQueryReturnType<TData, TError> = UseBaseQueryReturnType<TData, TError>;
+export { UseQueryReturnType }
+export { UseQueryReturnType as UseQueryReturnType_alias_1 }
+
+declare const VUE_QUERY_CLIENT = "VUE_QUERY_CLIENT";
+export { VUE_QUERY_CLIENT }
+export { VUE_QUERY_CLIENT as VUE_QUERY_CLIENT_alias_1 }
+
+declare const VueQueryPlugin: {
+    install: (app: any, options?: VueQueryPluginOptions) => void;
+};
+export { VueQueryPlugin }
+export { VueQueryPlugin as VueQueryPlugin_alias_1 }
+
+declare type VueQueryPluginOptions = ConfigOptions | ClientOptions;
+export { VueQueryPluginOptions }
+export { VueQueryPluginOptions as VueQueryPluginOptions_alias_1 }
+
+export { WithRequired }
+
+export { }