import { Injector, Signal, Provider, EnvironmentProviders } from '@angular/core';
import { QueryKey, QueryFunctionContext, DefaultError, WithRequired, QueryObserverOptions, DataTag, QueryObserverResult, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryFilters, MutationFilters, MutationObserverOptions, MutateOptions, MutationObserver, MutationObserverResult, DefinedQueryObserverResult, QueryClient as QueryClient$1, FetchQueryOptions, FetchInfiniteQueryOptions, QueryObserverLoadingErrorResult, QueryObserverSuccessResult, QueryClientConfig, QueryObserverBaseResult } from '@tanstack/query-core';
export * from '@tanstack/query-core';
import { Observable, OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';

type QueryFunctionWithObservable<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T> | Observable<T>;
interface Options {
    injector?: Injector;
}
interface _CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryKey'>, Options {
}
type CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = Omit<_CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryFn'> & {
    queryFn: QueryFunctionWithObservable<TQueryFnData, TQueryKey>;
};

type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
    initialData?: undefined;
};
type NonUndefinedGuard<T> = T extends undefined ? never : T;
type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
};
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
    queryKey: DataTag<TQueryKey, TData>;
};
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
    queryKey: DataTag<TQueryKey, TData>;
};
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): CreateInfiniteQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey, TPageParam> & {
    queryKey: DataTag<TQueryKey, TData>;
};

type ObservableQueryResult<Data, Error = any> = Observable<QueryObserverResult<Data, Error>>;
type SignalQueryResult<Data, Error = any> = Signal<QueryObserverResult<Data, Error>>;
type Result<T> = {
    result$: Observable<T>;
    result: Signal<T>;
    updateOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> | DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): void;
};

interface _CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends WithRequired<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'>, Options {
}
type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Omit<_CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
    queryFn: QueryFunctionWithObservable<TQueryFnData, TQueryKey, TPageParam>;
};
interface InfiniteQueryObject {
    use: <TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>) => Result<InfiniteQueryObserverResult<TData, TError>>;
}
/**
 *
 * Optionally pass an injector that will be used than the current one.
 * Can be useful if you want to use it in ngOnInit hook for example.
 *
 * @example
 *
 * injector = inject(Injector);
 *
 * ngOnInit() {
 *  const infiniteQuery = injectInfiniteQuery({ injector: this.injector });
 * }
 *
 */
declare function injectInfiniteQuery(options?: {
    injector?: Injector;
}): <TQueryFnData, TError = Error, TData = InfiniteData<TQueryFnData, unknown>, TQueryKey extends QueryKey = readonly unknown[], TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>) => Result<InfiniteQueryObserverResult<TData, TError>>;

interface IsFetchingObject {
    use: (filters?: QueryFilters) => {
        result$: Observable<number>;
        toSignal: () => Signal<number | undefined>;
    };
}
/**
 *
 * Optionally pass an injector that will be used than the current one.
 * Can be useful if you want to use it in ngOnInit hook for example.
 *
 * @example
 *
 * injector = inject(Injector);
 *
 * ngOnInit() {
 *  const isFetching = injectIsFetching({ injector: this.injector });
 * }
 *
 */
declare function injectIsFetching(options?: {
    injector?: Injector;
}): (filters?: QueryFilters) => {
    result$: Observable<number>;
    toSignal: () => Signal<number | undefined>;
};

interface IsMutatingObject {
    use: (filters?: MutationFilters) => {
        result$: Observable<number>;
        toSignal: () => Signal<number | undefined>;
    };
}
/**
 *
 * Optionally pass an injector that will be used than the current one.
 * Can be useful if you want to use it in ngOnInit hook for example.
 *
 * @example
 *
 * injector = inject(Injector);
 *
 * ngOnInit() {
 *  const isMutating = injectIsMutating({ injector: this.injector });
 * }
 *
 */
declare function injectIsMutating(options?: {
    injector?: Injector;
}): (filters?: MutationFilters) => {
    result$: Observable<number>;
    toSignal: () => Signal<number | undefined>;
};

type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, 'mutationFn'> & {
    mutationFn: (variables: TVariables) => Promise<TData> | Observable<TData>;
};
type MutationResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = {
    mutateAsync: (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => Promise<TData>;
    mutate: (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => void;
    reset: MutationObserver<TData, TError, TVariables, TContext>['reset'];
    setOptions: MutationObserver<TData, TError, TVariables, TContext>['setOptions'];
    result$: Observable<MutationObserverResult<TData, TError, TVariables, TContext>>;
    result: Signal<MutationObserverResult<TData, TError, TVariables, TContext>>;
};
interface MutationObject {
    use: <TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>) => MutationResult<TData, TError, TVariables, TContext>;
}
/**
 *
 * Optionally pass an injector that will be used than the current one.
 * Can be useful if you want to use it in ngOnInit hook for example.
 *
 * @example
 *
 * injector = inject(Injector);
 *
 * ngOnInit() {
 *  const mutation = injectMutation({ injector: this.injector });
 * }
 *
 */
declare function injectMutation(options?: {
    injector?: Injector;
}): <TData = unknown, TError = Error, TVariables = unknown, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>) => MutationResult<TData, TError, TVariables, TContext>;

interface QueryObject {
    use: (<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>) => Result<QueryObserverResult<TData, TError>>) | (<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>) => Result<DefinedQueryObserverResult<TData, TError>>) | (<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>) => any);
}
/**
 *
 * Optionally pass an injector that will be used than the current one.
 * Can be useful if you want to use it in ngOnInit hook for example.
 *
 * @example
 *
 * injector = inject(Injector);
 *
 * ngOnInit() {
 *  const todos = getTodos({ injector: this.injector }).result;
 * }
 *
 */
declare function injectQuery(options?: {
    injector?: Injector;
}): {
    <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = readonly unknown[]>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): Result<QueryObserverResult<TData, TError>>;
    <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = readonly unknown[]>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): Result<DefinedQueryObserverResult<TData, TError>>;
};

/** @public */
declare function provideQueryClient(queryClientOrFactory: QueryClient$1 | (() => QueryClient$1)): Provider;
/** @public */
declare function injectQueryClient(): QueryClient;
/** should be exported for @test */
declare class QueryClient extends QueryClient$1 {
    #private;
    /**
     *
     * Asynchronous function that can be used to get an existing query's cached data.
     * If the query does not exist, queryClient.fetchQuery will be called and its results
     * returned.
     *
     * @example
     *
     * queryClient = injectQueryClient();
     *
     * const data = await queryClient.ensureQueryData({ queryKey, queryFn })
     *
     */
    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>): Promise<TData>;
    ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, never>): Promise<TData>;
    /**
     *
     * Asynchronous method that can be used to fetch and cache a query.
     * It will either resolve with the data or throw with the error.
     * Use the prefetchQuery method if you just want to fetch a query without
     * needing the result.
     * If the query exists and the data is not invalidated or older than the given
     * staleTime, then the data from the cache will be returned.
     * Otherwise it will try to fetch the latest data.
     *
     * @example
     *
     * queryClient = injectQueryClient();
     *
     * const data = await queryClient.fetchQuery({ queryKey, queryFn })
     *
     */
    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>): Promise<TData>;
    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
    /**
     *
     * Asynchronous method that can be used to prefetch a query before
     * it is needed or rendered with useQuery and friends.
     * The method works the same as fetchQuery except that it will not
     * throw or return any data.
     *
     * @example
     *
     * queryClient = injectQueryClient();
     *
     * await queryClient.prefetchQuery({ queryKey, queryFn })
     *
     */
    prefetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>): Promise<void>;
    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
    /**
     *
     * Similar to fetchQuery but can be used to fetch and cache an infinite query
     *
     * @example
     *
     * queryClient = injectQueryClient();
     *
     * const data = await queryClient.fetchInfiniteQuery({ queryKey, queryFn, initialPageParam, getPreviousPageParam, getNextPageParam }) })
     *
     */
    fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
    fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
    /**
     *
     * Similar to prefetchQuery but can be used to prefetch and cache an infinite query.
     *
     * @example
     *
     * queryClient = injectQueryClient();
     *
     * await queryClient.prefetchInfiniteQuery({ queryKey, queryFn, initialPageParam, getPreviousPageParam, getNextPageParam })
     *
     */
    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
}

declare function mapResultData<T extends QueryObserverResult, R>(mapFn: (data: NonNullable<T['data']>) => R): OperatorFunction<T, QueryObserverResult<R>>;
declare function filterSuccessResult<T>(): OperatorFunction<QueryObserverResult<T>, QueryObserverSuccessResult<T>>;
declare function filterErrorResult<T, E>(): OperatorFunction<QueryObserverResult<T, E>, QueryObserverLoadingErrorResult<T, E>>;
declare function tapSuccessResult<T extends QueryObserverResult>(cb: (data: NonNullable<T['data']>) => void): MonoTypeOperatorFunction<T>;
declare function tapErrorResult<T extends QueryObserverResult>(cb: (error: NonNullable<T['error']>) => void): MonoTypeOperatorFunction<T>;
/**
 * An operator that takes values emitted by the source observable
 * until the `isFetching` property on the result is false.
 * It is intended to be used in scenarios where an observable stream should be listened to
 * until the result has finished fetching (e.g success or error).
 */
declare function takeUntilResultFinalize<T extends QueryObserverResult>(): MonoTypeOperatorFunction<T>;
/**
 * An operator that takes values emitted by the source observable
 * until the `isSuccess` property on the result is true.
 * It is intended to be used in scenarios where an observable stream should be listened to
 * until a successful result is emitted.
 */
declare function takeUntilResultSuccess<T extends QueryObserverResult>(): MonoTypeOperatorFunction<T>;
/**
 * An operator that takes values emitted by the source observable
 * until the `isError` property on the result is true.
 * It is intended to be used in scenarios where an observable stream should be listened to
 * until an error result is emitted.
 */
declare function takeUntilResultError<T extends QueryObserverResult>(): MonoTypeOperatorFunction<T>;
declare function startWithPendingQueryResult<T>(): MonoTypeOperatorFunction<T>;
type DataTypes$1<T extends QueryObserverResult[] | Record<string, QueryObserverResult<any>>> = {
    [P in keyof T]: T[P] extends QueryObserverResult<infer R> ? R : never;
};
type UnifiedTypes$1<T> = T extends Array<QueryObserverResult<any>> ? DataTypes$1<T> : T extends Record<string, QueryObserverResult<any>> ? DataTypes$1<T> : never;
/**
 *
 *  This operator is used to merge multiple queries into one.
 *  It will return a new base query result that will merge the results of all the queries.
 *
 * @example
 *
 * const query = combineLatest({
 *   todos: todos.result$,
 *   posts: posts.result$,
 * }).pipe(
 *   intersectResults$(({ todos, posts }) => {
 *     return { ... }
 *   })
 * )
 * @example
 *
 * const query = combineLatest([todos.result$, posts.result$]).pipe(
 *   intersectResults$(([todos, posts]) => {
 *     return { ... }
 *   })
 * )
 */
declare function intersectResults$<T extends Array<QueryObserverResult<any>> | Record<string, QueryObserverResult<any>>, R>(mapFn: (values: UnifiedTypes$1<T>) => R): OperatorFunction<T, QueryObserverResult<R> & {
    all: T;
}>;

type QueryClientConfigFn = () => QueryClientConfig;
declare function provideQueryClientOptions(options: QueryClientConfig): EnvironmentProviders;
declare function provideQueryClientOptions(options: QueryClientConfigFn): EnvironmentProviders;

type DataTypes<T extends Array<Signal<QueryObserverBaseResult>> | Record<string, Signal<QueryObserverBaseResult<any>>>> = {
    [P in keyof T]: T[P] extends Signal<QueryObserverBaseResult<infer R>> ? R : never;
};
type UnifiedTypes<T> = T extends Array<Signal<QueryObserverBaseResult<any>>> ? DataTypes<T> : T extends Record<string, Signal<QueryObserverBaseResult<any>>> ? DataTypes<T> : never;
/**
 *
 *  @experimental
 *
 *  This function is used to merge multiple signal queries into one.
 *  It will return a new base query result that will merge the results of all the queries.
 *  Note that it should be used inside injection context
 *
 * @example
 *
 * const query = intersetResults({
 *   todos: todos.result$,
 *   posts: posts.result$,
 * }, ({ todos, posts }) => {
 *   return todos + posts;
 * })
 *
 *
 * @example
 *
 * const query = intersectResults(
 *   [
 *     this.todosService.getTodo('1').result,
 *     this.todosService.getTodo('2').result,
 *   ],
 *  ([todoOne, todoTwo]) => {
 *    return todoOne.title + todoTwo.title;
 *  }
 * );
 */
declare function intersectResults<T extends Array<Signal<QueryObserverResult<any>>> | Record<string, Signal<QueryObserverResult<any>>>, R>(signals: T, mapFn: (values: UnifiedTypes<T>) => R): Signal<QueryObserverResult<R> & {
    all: T;
}>;

declare function toPromise<T>({ source, signal, }: {
    source: Observable<T>;
    signal?: AbortSignal;
}): Promise<T>;
declare function createSuccessObserverResult<T, Error = DefaultError>(data: T): QueryObserverResult<T, Error>;
declare function createPendingObserverResult<T = unknown, Error = DefaultError>(): QueryObserverResult<T, Error>;

/** @public */
declare function provideQueryConfig(config: {
    query?: QueryObject | (() => QueryObject);
    mutation?: MutationObject | (() => MutationObject);
    isMutating?: IsMutatingObject | (() => IsMutatingObject);
    isFetching?: IsFetchingObject | (() => IsFetchingObject);
    infiniteQuery?: InfiniteQueryObject | (() => InfiniteQueryObject);
}): Provider;

export { createPendingObserverResult, createSuccessObserverResult, filterErrorResult, filterSuccessResult, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectMutation, injectQuery, injectQueryClient, intersectResults, intersectResults$, mapResultData, provideQueryClient, provideQueryClientOptions, provideQueryConfig, queryOptions, startWithPendingQueryResult, takeUntilResultError, takeUntilResultFinalize, takeUntilResultSuccess, tapErrorResult, tapSuccessResult, toPromise };
export type { CreateMutationOptions, MutationResult, ObservableQueryResult, QueryClientConfigFn, SignalQueryResult };