@tanstack/angular-query-experimental 5.80.8 → 5.80.10

package/dist-ts/src/infinite-query-options.d.ts

@@ -1,45 +0,0 @@
-import type { DataTag, DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, SkipToken } from '@tanstack/query-core';
-import type { CreateInfiniteQueryOptions } from './types';
-export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    initialData?: undefined | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
-};
-export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
-    queryFn?: Exclude<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken | undefined>;
-};
-export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) | undefined;
-};
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export 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>;
-};
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
-};
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-export 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>;
-};
-//# sourceMappingURL=infinite-query-options.d.ts.map

package/dist-ts/src/inject-infinite-query.d.ts

@@ -1,40 +0,0 @@
-import { Injector } from '@angular/core';
-import type { DefaultError, InfiniteData, QueryKey } from '@tanstack/query-core';
-import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult, DefinedCreateInfiniteQueryResult } from './types';
-import type { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from './infinite-query-options';
-export interface InjectInfiniteQueryOptions {
-    /**
-     * The `Injector` in which to create the infinite query.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
-}
-/**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): DefinedCreateInfiniteQueryResult<TData, TError>;
-/**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
-/**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param injectInfiniteQueryFn - A function that returns infinite query options.
- * @param options - Additional configuration.
- * @returns The infinite query result.
- * @public
- */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
-//# sourceMappingURL=inject-infinite-query.d.ts.map

package/dist-ts/src/inject-is-fetching.d.ts

@@ -1,23 +0,0 @@
-import { Injector } from '@angular/core';
-import type { QueryFilters } from '@tanstack/query-core';
-import type { Signal } from '@angular/core';
-export interface InjectIsFetchingOptions {
-    /**
-     * The `Injector` in which to create the isFetching signal.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
-}
-/**
- * Injects a signal that tracks the number of queries that your application is loading or
- * fetching in the background.
- *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
- * @param options - Additional configuration
- * @returns signal with number of loading or fetching queries.
- * @public
- */
-export declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
-//# sourceMappingURL=inject-is-fetching.d.ts.map

package/dist-ts/src/inject-is-mutating.d.ts

@@ -1,22 +0,0 @@
-import { Injector } from '@angular/core';
-import type { MutationFilters } from '@tanstack/query-core';
-import type { Signal } from '@angular/core';
-export interface InjectIsMutatingOptions {
-    /**
-     * The `Injector` in which to create the isMutating signal.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
-}
-/**
- * Injects a signal that tracks the number of mutations that your application is fetching.
- *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
- * @param options - Additional configuration
- * @returns signal with number of fetching mutations.
- * @public
- */
-export declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
-//# sourceMappingURL=inject-is-mutating.d.ts.map

package/dist-ts/src/inject-mutation-state.d.ts

@@ -1,28 +0,0 @@
-import { Injector } from '@angular/core';
-import type { Signal } from '@angular/core';
-import type { Mutation, MutationFilters, MutationState } from '@tanstack/query-core';
-type MutationStateOptions<TResult = MutationState> = {
-    filters?: MutationFilters;
-    select?: (mutation: Mutation) => TResult;
-};
-/**
- * @public
- */
-export interface InjectMutationStateOptions {
-    /**
-     * The `Injector` in which to create the mutation state signal.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
-}
-/**
- * Injects a signal that tracks the state of all mutations.
- * @param injectMutationStateFn - A function that returns mutation state options.
- * @param options - The Angular injector to use.
- * @returns The signal that tracks the state of all mutations.
- * @public
- */
-export declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
-export {};
-//# sourceMappingURL=inject-mutation-state.d.ts.map

package/dist-ts/src/inject-mutation.d.ts

@@ -1,23 +0,0 @@
-import { Injector } from '@angular/core';
-import type { DefaultError } from '@tanstack/query-core';
-import type { CreateMutationResult } from './types';
-import type { CreateMutationOptions } from './mutation-options';
-export interface InjectMutationOptions {
-    /**
-     * The `Injector` in which to create the mutation.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
-}
-/**
- * Injects a mutation: an imperative function that can be invoked which typically performs server side effects.
- *
- * Unlike queries, mutations are not run automatically.
- * @param injectMutationFn - A function that returns mutation options.
- * @param options - Additional configuration
- * @returns The mutation.
- * @public
- */
-export declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TContext>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TContext>;
-//# sourceMappingURL=inject-mutation.d.ts.map

package/dist-ts/src/inject-queries.d.ts

@@ -1,78 +0,0 @@
-import { Injector } from '@angular/core';
-import type { Signal } from '@angular/core';
-import type { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryFunction, QueryKey, QueryObserverOptions, QueryObserverResult, ThrowOnError } from '@tanstack/query-core';
-type QueryObserverOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'placeholderData'> & {
-    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
-};
-type MAXIMUM_DEPTH = 20;
-type SkipTokenForUseQueries = symbol;
-type GetOptions<T> = T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-    data: infer TData;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? QueryObserverOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverOptionsForCreateQueries<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
-    select: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : QueryObserverOptionsForCreateQueries;
-type GetResults<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
-} ? QueryObserverResult<TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? QueryObserverResult<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? QueryObserverResult<TData, TError> : T extends [any, infer TError, infer TData] ? QueryObserverResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? QueryObserverResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverResult<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
-    select: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : QueryObserverResult;
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- * @public
- */
-export type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : 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<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
-/**
- * QueriesResults reducer recursively maps type param to results
- * @public
- */
-export type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
-    ...Tail
-], [
-    ...TResult,
-    GetResults<Head>
-], [
-    ...TDepth,
-    1
-]> : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>> ? Array<QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError>> : Array<QueryObserverResult>;
-/**
- * @param root0
- * @param root0.queries
- * @param root0.combine
- * @param injector
- * @param injector
- * @public
- */
-export declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
-    queries: Signal<[...QueriesOptions<T>]>;
-    combine?: (result: QueriesResults<T>) => TCombinedResult;
-}, injector?: Injector): Signal<TCombinedResult>;
-export {};
-//# sourceMappingURL=inject-queries.d.ts.map

package/dist-ts/src/providers.d.ts

@@ -1,217 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { QueryClient } from '@tanstack/query-core';
-import type { Provider } from '@angular/core';
-import type { DevtoolsButtonPosition, DevtoolsErrorType, DevtoolsPosition } from '@tanstack/query-devtools';
-/**
- * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the
- * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}
- * for the entire application. Internally it calls `provideQueryClient`.
- * You can use `provideQueryClient` to provide a different `QueryClient` instance for a part
- * of the application or for unit testing purposes.
- * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
- * @returns a provider object that can be used to provide the `QueryClient` instance.
- */
-export declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
-/**
- * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
- *
- * Allows to configure a `QueryClient` and optional features such as developer tools.
- *
- * **Example - standalone**
- *
- * ```ts
- * import {
- *   provideTanStackQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * bootstrapApplication(AppComponent, {
- *   providers: [provideTanStackQuery(new QueryClient())],
- * })
- * ```
- *
- * **Example - NgModule-based**
- *
- * ```ts
- * import {
- *   provideTanStackQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * @NgModule({
- *   declarations: [AppComponent],
- *   imports: [BrowserModule],
- *   providers: [provideTanStackQuery(new QueryClient())],
- *   bootstrap: [AppComponent],
- * })
- * export class AppModule {}
- * ```
- *
- * You can also enable optional developer tools by adding `withDevtools`. By
- * default the tools will then be loaded when your app is in development mode.
- * ```ts
- * import {
- *   provideTanStackQuery,
- *   withDevtools
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * bootstrapApplication(AppComponent,
- *   {
- *     providers: [
- *       provideTanStackQuery(new QueryClient(), withDevtools())
- *     ]
- *   }
- * )
- * ```
- *
- * **Example: using an InjectionToken**
- *
- * ```ts
- * export const MY_QUERY_CLIENT = new InjectionToken('', {
- *   factory: () => new QueryClient(),
- * })
- *
- * // In a lazy loaded route or lazy loaded component's providers array:
- * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
- * ```
- * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
- * @param features - Optional features to configure additional Query functionality.
- * @returns A set of providers to set up TanStack Query.
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
- * @see withDevtools
- */
-export declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
-/**
- * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
- *
- * Allows to configure a `QueryClient`.
- * @param queryClient - A `QueryClient` instance.
- * @returns A set of providers to set up TanStack Query.
- * @public
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
- * @deprecated Use `provideTanStackQuery` instead.
- */
-export declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
-/**
- * Helper type to represent a Query feature.
- */
-export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
-    ɵkind: TFeatureKind;
-    ɵproviders: Array<Provider>;
-}
-/**
- * Helper function to create an object that represents a Query feature.
- * @param kind -
- * @param providers -
- * @returns A Query feature.
- */
-export declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;
-/**
- * A type alias that represents a feature which enables developer tools.
- * The type is used to describe the return value of the `withDevtools` function.
- * @public
- * @see {@link withDevtools}
- */
-export type DeveloperToolsFeature = QueryFeature<'DeveloperTools'>;
-/**
- * A type alias that represents a feature which enables persistence.
- * The type is used to describe the return value of the `withPersistQueryClient` function.
- * @public
- */
-export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
-/**
- * Options for configuring the TanStack Query devtools.
- * @public
- */
-export interface DevtoolsOptions {
-    /**
-     * Set this true if you want the devtools to default to being open
-     */
-    initialIsOpen?: boolean;
-    /**
-     * The position of the TanStack logo to open and close the devtools panel.
-     * `top-left` | `top-right` | `bottom-left` | `bottom-right` | `relative`
-     * Defaults to `bottom-right`.
-     */
-    buttonPosition?: DevtoolsButtonPosition;
-    /**
-     * The position of the TanStack Query devtools panel.
-     * `top` | `bottom` | `left` | `right`
-     * Defaults to `bottom`.
-     */
-    position?: DevtoolsPosition;
-    /**
-     * Custom instance of QueryClient
-     */
-    client?: QueryClient;
-    /**
-     * Use this so you can define custom errors that can be shown in the devtools.
-     */
-    errorTypes?: Array<DevtoolsErrorType>;
-    /**
-     * Use this to pass a nonce to the style tag that is added to the document head. This is useful if you are using a Content Security Policy (CSP) nonce to allow inline styles.
-     */
-    styleNonce?: string;
-    /**
-     * Use this so you can attach the devtool's styles to a specific element in the DOM.
-     */
-    shadowDOMTarget?: ShadowRoot;
-    /**
-     * Whether the developer tools should load.
-     * - `auto`- (Default) Lazily loads devtools when in development mode. Skips loading in production mode.
-     * - `true`- Always load the devtools, regardless of the environment.
-     * - `false`- Never load the devtools, regardless of the environment.
-     *
-     * You can use `true` and `false` to override loading developer tools from an environment file.
-     * For example, a test environment might run in production mode but you may want to load developer tools.
-     *
-     * Additionally, you can use a signal in the callback to dynamically load the devtools based on a condition. For example,
-     * a signal created from a RxJS observable that listens for a keyboard shortcut.
-     *
-     * **Example**
-     * ```ts
-     *    withDevtools(() => ({
-     *      initialIsOpen: true,
-     *      loadDevtools: inject(ExampleService).loadDevtools()
-     *    }))
-     *  ```
-     */
-    loadDevtools?: 'auto' | boolean;
-}
-/**
- * Enables developer tools.
- *
- * **Example**
- *
- * ```ts
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideTanStackQuery(new QueryClient(), withDevtools())
- *   ]
- * }
- * ```
- * By default the devtools will be loaded when Angular runs in development mode and rendered in `<body>`.
- *
- * If you need more control over when devtools are loaded, you can use the `loadDevtools` option. This is particularly useful if you want to load devtools based on environment configurations. For instance, you might have a test environment running in production mode but still require devtools to be available.
- *
- * If you need more control over where devtools are rendered, consider `injectDevtoolsPanel`. This allows rendering devtools inside your own devtools for example.
- * @param withDevtoolsFn - A function that returns `DevtoolsOptions`.
- * @returns A set of providers for use with `provideTanStackQuery`.
- * @public
- * @see {@link provideTanStackQuery}
- * @see {@link DevtoolsOptions}
- */
-export declare function withDevtools(withDevtoolsFn?: () => DevtoolsOptions): DeveloperToolsFeature;
-/**
- * A type alias that represents all Query features available for use with `provideTanStackQuery`.
- * Features can be enabled by adding special functions to the `provideTanStackQuery` call.
- * See documentation for each symbol to find corresponding function name. See also `provideTanStackQuery`
- * documentation on how to use those functions.
- * @public
- * @see {@link provideTanStackQuery}
- */
-export type QueryFeatures = DeveloperToolsFeature | PersistQueryClientFeature;
-export declare const queryFeatures: readonly ["DeveloperTools", "PersistQueryClient"];
-export type QueryFeatureKind = (typeof queryFeatures)[number];
-//# sourceMappingURL=providers.d.ts.map

package/dist-ts/src/query-options.d.ts

@@ -1,88 +0,0 @@
-import type { DataTag, DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, SkipToken } from '@tanstack/query-core';
-import type { CreateQueryOptions } from './types';
-export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
-};
-export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
-    queryFn?: Exclude<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken | undefined>;
-};
-export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
-    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
-    queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
-};
-/**
- * Allows to share and re-use query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- *
- * **Example**
- *
- * ```ts
- *  const { queryKey } = queryOptions({
- *     queryKey: ['key'],
- *     queryFn: () => Promise.resolve(5),
- *     //  ^?  Promise<number>
- *   })
- *
- *   const queryClient = new QueryClient()
- *   const data = queryClient.getQueryData(queryKey)
- *   //    ^?  number | undefined
- * ```
- * @param options - The query options to tag with the type from `queryFn`.
- * @returns The tagged query options.
- * @public
- */
-export 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, TQueryFnData, TError>;
-};
-/**
- * Allows to share and re-use query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- *
- * **Example**
- *
- * ```ts
- *  const { queryKey } = queryOptions({
- *     queryKey: ['key'],
- *     queryFn: () => Promise.resolve(5),
- *     //  ^?  Promise<number>
- *   })
- *
- *   const queryClient = new QueryClient()
- *   const data = queryClient.getQueryData(queryKey)
- *   //    ^?  number | undefined
- * ```
- * @param options - The query options to tag with the type from `queryFn`.
- * @returns The tagged query options.
- * @public
- */
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
-};
-/**
- * Allows to share and re-use query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- *
- * **Example**
- *
- * ```ts
- *  const { queryKey } = queryOptions({
- *     queryKey: ['key'],
- *     queryFn: () => Promise.resolve(5),
- *     //  ^?  Promise<number>
- *   })
- *
- *   const queryClient = new QueryClient()
- *   const data = queryClient.getQueryData(queryKey)
- *   //    ^?  number | undefined
- * ```
- * @param options - The query options to tag with the type from `queryFn`.
- * @returns The tagged query options.
- * @public
- */
-export 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, TQueryFnData, TError>;
-};
-//# sourceMappingURL=query-options.d.ts.map

package/dist-ts/src/signal-proxy.d.ts

@@ -1,12 +0,0 @@
-import type { Signal } from '@angular/core';
-export type MapToSignals<T> = {
-    [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>;
-};
-/**
- * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
- * Functions on the object are passed through as-is.
- * @param inputSignal - `Signal` that must return an object.
- * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
- */
-export declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;
-//# sourceMappingURL=signal-proxy.d.ts.map

package/dist-ts/src/test-setup.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=test-setup.d.ts.map