@tanstack/lit-query 0.2.11 → 0.2.13

package/build/legacy/index.d.ts

@@ -0,0 +1,781 @@
+import { DataTag, DefaultError, DefinedQueryObserverResult, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, InitialDataFunction, MutateFunction, Mutation, MutationFilters, MutationObserverOptions, MutationObserverResult, MutationState, NonUndefinedGuard, OmitKeyof, QueryClient, QueryFilters, QueryFunction, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken, ThrowOnError } from "@tanstack/query-core";
+import { LitElement, ReactiveControllerHost, TemplateResult } from "lit";
+export * from "@tanstack/query-core";
+//#region src/accessor.d.ts
+/**
+ * A value that can be passed directly or read from a zero-argument getter.
+ *
+ * Lit Query APIs read function accessors during host updates, so the getter can
+ * depend on reactive host state.
+ *
+ * @example
+ * ```ts
+ * const staticKey: Accessor<readonly unknown[]> = ['todos']
+ * const reactiveKey: Accessor<readonly unknown[]> = () => ['todos', this.userId]
+ * ```
+ */
+type Accessor<T> = T | (() => T);
+/**
+ * A callable accessor with a `current` property for reading the latest
+ * controller result.
+ *
+ * Controller creators and cache state helpers return this shape so render code
+ * can use either `result()` or `result.current`.
+ *
+ * @example
+ * ```ts
+ * const query = this.todos()
+ * const sameQuery = this.todos.current
+ * ```
+ */
+type ValueAccessor<T> = (() => T) & {
+  readonly current: T;
+};
+//#endregion
+//#region src/context.d.ts
+/**
+ * Lit context key used by `QueryClientProvider` and host-bound APIs to share a
+ * `QueryClient` through the DOM tree.
+ *
+ * Most applications use `QueryClientProvider` instead of interacting with this
+ * context directly.
+ */
+declare const queryClientContext: {
+  __context__: QueryClient;
+};
+/**
+ * Registers a `QueryClient` as a process-local fallback for APIs that resolve a
+ * client without an explicit argument.
+ *
+ * `QueryClientProvider` calls this automatically while it is connected. Prefer
+ * passing an explicit client or rendering under a provider when possible.
+ *
+ * @param client - The query client to register as the current default.
+ */
+declare function registerDefaultQueryClient(client: QueryClient): void;
+/**
+ * Unregisters a client previously registered with
+ * `registerDefaultQueryClient`.
+ *
+ * `QueryClientProvider` calls this automatically when it disconnects.
+ *
+ * @param client - The query client registration to release.
+ */
+declare function unregisterDefaultQueryClient(client: QueryClient): void;
+/**
+ * Returns the registered default `QueryClient`, if exactly one default client is
+ * available.
+ *
+ * @returns The default query client, or `undefined` when there is no registered
+ * client or more than one registered client.
+ */
+declare function getDefaultQueryClient(): QueryClient | undefined;
+/**
+ * Resolves the current default `QueryClient` registered by a connected
+ * `QueryClientProvider`.
+ *
+ * This helper is useful outside a Lit reactive controller when a single
+ * provider is mounted. It throws if no client is registered or if multiple
+ * clients are mounted and the default would be ambiguous.
+ *
+ * @returns The single registered query client.
+ */
+declare function useQueryClient(): QueryClient;
+/**
+ * Resolves an explicit `QueryClient` or falls back to `useQueryClient`.
+ *
+ * @param explicit - Optional client supplied by the caller.
+ * @returns The explicit client when provided, otherwise the current default
+ * client.
+ */
+declare function resolveQueryClient(explicit?: QueryClient): QueryClient;
+//#endregion
+//#region src/QueryClientProvider.d.ts
+/**
+ * Lit element that provides a `QueryClient` to descendant Lit Query
+ * controllers through Lit context.
+ *
+ * The `client` is a property, not an attribute. When rendering this element in
+ * a Lit template, bind it with property binding: `.client=${queryClient}`.
+ * The provider throws if it connects without a client, or if an already
+ * connected provider has its client cleared.
+ *
+ * This class is not registered as a custom element by the package. Applications
+ * must register either a subclass or the class itself with
+ * `customElements.define`.
+ *
+ * @example
+ * ```ts
+ * import { html, LitElement } from 'lit'
+ * import { QueryClient, QueryClientProvider } from '@tanstack/lit-query'
+ *
+ * const queryClient = new QueryClient()
+ *
+ * class AppQueryProvider extends QueryClientProvider {
+ *   constructor() {
+ *     super()
+ *     this.client = queryClient
+ *   }
+ * }
+ *
+ * customElements.define('app-query-provider', AppQueryProvider)
+ *
+ * class AppRoot extends LitElement {
+ *   render() {
+ *     return html`<app-query-provider><todos-view></todos-view></app-query-provider>`
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { html } from 'lit'
+ * import { QueryClient, QueryClientProvider } from '@tanstack/lit-query'
+ *
+ * const queryClient = new QueryClient()
+ *
+ * customElements.define('query-client-provider', QueryClientProvider)
+ *
+ * const view = html`
+ *   <query-client-provider .client=${queryClient}>
+ *     <todos-view></todos-view>
+ *   </query-client-provider>
+ * `
+ * ```
+ */
+declare class QueryClientProvider extends LitElement {
+  /** @internal */
+  static properties: {
+    client: {
+      attribute: boolean;
+    };
+  };
+  /**
+   * The `QueryClient` provided to descendant controllers and global fallback
+   * helpers while this provider is connected.
+   *
+   * Bind this as a property in Lit templates with `.client=${queryClient}`.
+   */
+  client: QueryClient;
+  private readonly contextProvider;
+  private mountedClient;
+  constructor();
+  /** @internal */
+  connectedCallback(): void;
+  /** @internal */
+  disconnectedCallback(): void;
+  /** @internal */
+  protected willUpdate(changedProperties: Map<PropertyKey, unknown>): void;
+  /** @internal */
+  render(): TemplateResult;
+  private mountClient;
+  private unmountClient;
+  private requireClient;
+}
+//#endregion
+//#region src/createInfiniteQueryController.d.ts
+/**
+ * Options accepted by `createInfiniteQueryController`.
+ *
+ * This is the Lit adapter shape for `InfiniteQueryObserverOptions`. Pass it
+ * directly or through an `Accessor` when the options depend on Lit host state.
+ */
+type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>;
+/**
+ * Accessor returned by `createInfiniteQueryController`.
+ *
+ * Call the accessor or read its `current` property to get the latest infinite
+ * query result. The attached methods delegate to the active infinite query
+ * observer.
+ */
+type InfiniteQueryResultAccessor<TData, TError> = ValueAccessor<InfiniteQueryObserverResult<TData, TError>> & {
+  /** Refetches the current infinite query. */
+  refetch: InfiniteQueryObserverResult<TData, TError>['refetch'];
+  /** Fetches the next page for the current infinite query. */
+  fetchNextPage: InfiniteQueryObserverResult<TData, TError>['fetchNextPage'];
+  /** Fetches the previous page for the current infinite query. */
+  fetchPreviousPage: InfiniteQueryObserverResult<TData, TError>['fetchPreviousPage'];
+  /** Removes the controller from its Lit host and unsubscribes observers. */
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that subscribes the host to an infinite
+ * query.
+ *
+ * The returned accessor is callable and also exposes `current`, `refetch`,
+ * `fetchNextPage`, `fetchPreviousPage`, and `destroy`. When `options` is a
+ * function, it is re-read during host updates so query keys and options can
+ * follow reactive host state.
+ *
+ * If `queryClient` is omitted, the controller resolves the client from the
+ * nearest connected `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the infinite query
+ * subscription.
+ * @param options - Infinite query observer options, or a getter that returns
+ * options.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the latest infinite query result with page helper
+ * methods.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { createInfiniteQueryController } from '@tanstack/lit-query'
+ *
+ * class ProjectsView extends LitElement {
+ *   private readonly projects = createInfiniteQueryController(this, {
+ *     queryKey: ['projects'],
+ *     queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *     initialPageParam: 0,
+ *     getNextPageParam: (lastPage) => lastPage.nextCursor,
+ *   })
+ *
+ *   render() {
+ *     const query = this.projects()
+ *
+ *     return html`
+ *       <button ?disabled=${!query.hasNextPage} @click=${() => this.projects.fetchNextPage()}>
+ *         Load more
+ *       </button>
+ *     `
+ *   }
+ * }
+ * ```
+ */
+declare function createInfiniteQueryController<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(host: ReactiveControllerHost, options: Accessor<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>, queryClient?: QueryClient): InfiniteQueryResultAccessor<TData, TError>;
+//#endregion
+//#region src/createMutationController.d.ts
+/**
+ * Options accepted by `createMutationController`.
+ *
+ * This is the Lit adapter shape for `MutationObserverOptions`. Pass it directly
+ * or through an `Accessor` when the options depend on Lit host state.
+ */
+type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
+/**
+ * Accessor returned by `createMutationController`.
+ *
+ * Call the accessor or read its `current` property to get the latest mutation
+ * result. The attached methods delegate to the active mutation observer.
+ */
+type MutationResultAccessor<TData, TError, TVariables, TOnMutateResult> = ValueAccessor<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>> & {
+  /**
+   * Starts the mutation and swallows the returned promise.
+   *
+   * Throws synchronously if no `QueryClient` can be resolved.
+   */
+  mutate: (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+  /**
+   * Starts the mutation and returns the observer promise.
+   *
+   * Rejects if no `QueryClient` can be resolved.
+   */
+  mutateAsync: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>['mutate'];
+  /** Resets the mutation observer to its idle state. */
+  reset: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>['reset'];
+  /** Removes the controller from its Lit host and unsubscribes observers. */
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that subscribes the host to a mutation.
+ *
+ * The returned accessor is callable and also exposes `current`, `mutate`,
+ * `mutateAsync`, `reset`, and `destroy`. When `options` is a function, it is
+ * re-read during host updates so mutation options can follow reactive host
+ * state.
+ *
+ * If `queryClient` is omitted, the controller resolves the client from the
+ * nearest connected `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the mutation
+ * subscription.
+ * @param options - Mutation observer options, or a getter that returns options.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the latest mutation result with mutation helper
+ * methods.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { createMutationController } from '@tanstack/lit-query'
+ *
+ * class AddTodoForm extends LitElement {
+ *   private readonly addTodo = createMutationController(this, {
+ *     mutationFn: (title: string) =>
+ *       fetch('/api/todos', { method: 'POST', body: JSON.stringify({ title }) }),
+ *   })
+ *
+ *   render() {
+ *     const mutation = this.addTodo()
+ *
+ *     return html`
+ *       <button ?disabled=${mutation.isPending} @click=${() => this.addTodo.mutate('Ship docs')}>
+ *         Add todo
+ *       </button>
+ *     `
+ *   }
+ * }
+ * ```
+ */
+declare function createMutationController<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(host: ReactiveControllerHost, options: Accessor<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>>, queryClient?: QueryClient): MutationResultAccessor<TData, TError, TVariables, TOnMutateResult>;
+//#endregion
+//#region src/createQueriesController.d.ts
+/**
+ * Options for one query inside `createQueriesController`.
+ *
+ * This mirrors `QueryObserverOptions` and is used by the tuple inference that
+ * maps each input query to its corresponding result.
+ */
+type CreateQueriesInput<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>;
+type CreateQueriesInputForController<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueriesInput<TQueryFnData, TError, TData, TQueryKey>, never>;
+type MAXIMUM_DEPTH = 20;
+type SkipTokenForCreateQueries = symbol;
+type GetCreateQueriesInput<T> = T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+  data: infer TData;
+} ? CreateQueriesInputForController<TQueryFnData, TError, TData> : T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+} ? CreateQueriesInputForController<TQueryFnData, TError> : T extends {
+  data: infer TData;
+  error?: infer TError;
+} ? CreateQueriesInputForController<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueriesInputForController<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueriesInputForController<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueriesInputForController<TQueryFnData> : T extends {
+  queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForCreateQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? CreateQueriesInputForController<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : CreateQueriesInputForController;
+type GetDefinedOrUndefinedCreateQueriesResult<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>;
+type GetCreateQueriesResult<T> = T extends {
+  queryFnData: any;
+  error?: infer TError;
+  data: infer TData;
+} ? GetDefinedOrUndefinedCreateQueriesResult<T, TData, TError> : T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+} ? GetDefinedOrUndefinedCreateQueriesResult<T, TQueryFnData, TError> : T extends {
+  data: infer TData;
+  error?: infer TError;
+} ? GetDefinedOrUndefinedCreateQueriesResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedCreateQueriesResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedCreateQueriesResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedCreateQueriesResult<T, TQueryFnData> : T extends {
+  queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForCreateQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? GetDefinedOrUndefinedCreateQueriesResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : QueryObserverResult;
+type CreateQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueriesInputForController> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueriesInput<Head>] : T extends [infer Head, ...infer Tails] ? CreateQueriesOptions<[...Tails], [...TResults, GetCreateQueriesInput<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<CreateQueriesInputForController<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<CreateQueriesInputForController<TQueryFnData, TError, TData, TQueryKey>> : Array<CreateQueriesInputForController>;
+/**
+ * Tuple of query results inferred from the query inputs passed to
+ * `createQueriesController`.
+ */
+type CreateQueriesResults<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, GetCreateQueriesResult<Head>] : T extends [infer Head, ...infer Tails] ? CreateQueriesResults<[...Tails], [...TResults, GetCreateQueriesResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetCreateQueriesResult<T[K]>; };
+/**
+ * Options accepted by `createQueriesController`.
+ *
+ * `queries` can be a static list or a getter that returns the current list.
+ * `combine` can reshape the array of query results into a single value for the
+ * returned accessor.
+ */
+type CreateQueriesControllerOptions<TQueryOptions extends Array<any> = Array<any>, TCombinedResult = CreateQueriesResults<TQueryOptions>> = {
+  /** Query options to observe, or a getter that returns the current options. */
+  queries: Accessor<readonly [...CreateQueriesOptions<TQueryOptions>] | readonly [...{ [K in keyof TQueryOptions]: GetCreateQueriesInput<TQueryOptions[K]>; }]>;
+  /** Optional function that combines the query result array into one value. */
+  combine?: (result: CreateQueriesResults<TQueryOptions>) => TCombinedResult;
+};
+/**
+ * Accessor returned by `createQueriesController`.
+ *
+ * Call the accessor or read its `current` property to get the latest combined
+ * value.
+ */
+type QueriesResultAccessor<TCombinedResult> = ValueAccessor<TCombinedResult> & {
+  /** Removes the controller from its Lit host and unsubscribes observers. */
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that subscribes the host to multiple
+ * queries.
+ *
+ * The returned accessor is callable and also exposes `current` and `destroy`.
+ * When `options` or `options.queries` is a function, it is re-read during host
+ * updates so the query list can follow reactive host state.
+ *
+ * If `queryClient` is omitted, the controller resolves the client from the
+ * nearest connected `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the queries
+ * subscription.
+ * @param options - Queries controller options, or a getter that returns options.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the latest query results, or the value returned by
+ * `combine`.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { createQueriesController } from '@tanstack/lit-query'
+ *
+ * class DashboardView extends LitElement {
+ *   private readonly dashboard = createQueriesController(this, {
+ *     queries: [
+ *       { queryKey: ['stats'], queryFn: fetchStats },
+ *       { queryKey: ['projects'], queryFn: fetchProjects },
+ *     ],
+ *     combine: ([stats, projects]) => ({
+ *       stats: stats.data,
+ *       projects: projects.data ?? [],
+ *       isPending: stats.isPending || projects.isPending,
+ *     }),
+ *   })
+ *
+ *   render() {
+ *     const dashboard = this.dashboard()
+ *     return html`<p>Projects: ${dashboard.projects.length}</p>`
+ *   }
+ * }
+ * ```
+ */
+declare function createQueriesController<TQueryOptions extends Array<any>, TCombinedResult = CreateQueriesResults<TQueryOptions>>(host: ReactiveControllerHost, options: Accessor<CreateQueriesControllerOptions<TQueryOptions, TCombinedResult>>, queryClient?: QueryClient): QueriesResultAccessor<TCombinedResult>;
+//#endregion
+//#region src/createQueryController.d.ts
+/**
+ * Options accepted by `createQueryController`.
+ *
+ * This is the Lit adapter shape for `QueryObserverOptions`. It can be passed
+ * directly to `createQueryController`, or wrapped in an `Accessor` when the
+ * options depend on Lit host state.
+ */
+type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+/**
+ * Accessor returned by `createQueryController`.
+ *
+ * Call the accessor or read its `current` property to get the latest query
+ * result. The attached methods delegate to the active query observer.
+ */
+type QueryResultAccessor<TData, TError> = ValueAccessor<QueryObserverResult<TData, TError>> & {
+  /** Refetches the current query. */
+  refetch: QueryObserverResult<TData, TError>['refetch'];
+  /** Resolves with an optimistic query result, fetching first when needed. */
+  suspense: () => Promise<QueryObserverResult<TData, TError>>;
+  /** Removes the controller from its Lit host and unsubscribes observers. */
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that subscribes the host to a single query.
+ *
+ * The returned accessor is callable and also exposes `current`, `refetch`,
+ * `suspense`, and `destroy`. When `options` is a function, it is re-read during
+ * host updates so query keys and options can follow reactive host state.
+ *
+ * If `queryClient` is omitted, the controller resolves the client from the
+ * nearest connected `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the query
+ * subscription.
+ * @param options - Query observer options, or a getter that returns options.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the latest query result with query helper methods.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { createQueryController } from '@tanstack/lit-query'
+ *
+ * class TodosView extends LitElement {
+ *   private readonly todos = createQueryController(this, {
+ *     queryKey: ['todos'],
+ *     queryFn: async () => fetch('/api/todos').then((r) => r.json()),
+ *   })
+ *
+ *   render() {
+ *     const query = this.todos()
+ *
+ *     if (query.isPending) return html`Loading...`
+ *     if (query.isError) return html`Error`
+ *
+ *     return html`<ul>${query.data.map((todo) => html`<li>${todo.title}</li>`)}</ul>`
+ *   }
+ * }
+ * ```
+ */
+declare function createQueryController<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(host: ReactiveControllerHost, options: Accessor<CreateQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, queryClient?: QueryClient): QueryResultAccessor<TData, TError>;
+//#endregion
+//#region src/useIsFetching.d.ts
+/**
+ * Accessor returned by `useIsFetching`.
+ *
+ * Call the accessor or read its `current` property to get the number of
+ * currently fetching queries that match the filters.
+ */
+type IsFetchingAccessor = ValueAccessor<number> & {
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that tracks how many matching queries are
+ * currently fetching.
+ *
+ * When `filters` is a function, it is re-read during host updates so the count
+ * can follow reactive host state. If `queryClient` is omitted, the controller
+ * resolves the client from the nearest connected `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the cache
+ * subscription.
+ * @param filters - Query filters, or a getter that returns query filters.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the current number of matching fetching queries.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { useIsFetching } from '@tanstack/lit-query'
+ *
+ * class TodosStatus extends LitElement {
+ *   private readonly todosFetching = useIsFetching(this, {
+ *     queryKey: ['todos'],
+ *   })
+ *
+ *   render() {
+ *     return html`<span>${this.todosFetching()} active todo fetches</span>`
+ *   }
+ * }
+ * ```
+ */
+declare function useIsFetching(host: ReactiveControllerHost, filters?: Accessor<QueryFilters>, queryClient?: QueryClient): IsFetchingAccessor;
+//#endregion
+//#region src/useIsMutating.d.ts
+/**
+ * Accessor returned by `useIsMutating`.
+ *
+ * Call the accessor or read its `current` property to get the number of
+ * currently pending mutations that match the filters.
+ */
+type IsMutatingAccessor = ValueAccessor<number> & {
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that tracks how many matching mutations are
+ * currently pending.
+ *
+ * When `filters` is a function, it is re-read during host updates so the count
+ * can follow reactive host state. If `queryClient` is omitted, the controller
+ * resolves the client from the nearest connected `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the cache
+ * subscription.
+ * @param filters - Mutation filters, or a getter that returns mutation filters.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the current number of matching pending mutations.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { useIsMutating } from '@tanstack/lit-query'
+ *
+ * class MutationStatus extends LitElement {
+ *   private readonly savesPending = useIsMutating(this, {
+ *     mutationKey: ['save-project'],
+ *   })
+ *
+ *   render() {
+ *     return html`<span>${this.savesPending()} saves pending</span>`
+ *   }
+ * }
+ * ```
+ */
+declare function useIsMutating(host: ReactiveControllerHost, filters?: Accessor<MutationFilters>, queryClient?: QueryClient): IsMutatingAccessor;
+//#endregion
+//#region src/useMutationState.d.ts
+/**
+ * Options accepted by `useMutationState`.
+ */
+type MutationStateOptions<TResult> = {
+  /** Filters used to select mutations from the mutation cache. */
+  filters?: Accessor<MutationFilters>;
+  /** Maps each matching mutation to the value returned by the accessor. */
+  select?: (mutation: Mutation) => TResult;
+};
+/**
+ * Accessor returned by `useMutationState`.
+ *
+ * Call the accessor or read its `current` property to get the selected state for
+ * matching mutations.
+ */
+type MutationStateAccessor<TResult> = ValueAccessor<TResult[]> & {
+  /** Removes the controller from its Lit host and unsubscribes observers. */
+  destroy: () => void;
+};
+/**
+ * Creates a Lit reactive controller that selects state from matching mutations
+ * in the mutation cache.
+ *
+ * When `options.filters` is a function, it is re-read during host updates so
+ * the selection can follow reactive host state. If `queryClient` is omitted,
+ * the controller resolves the client from the nearest connected
+ * `QueryClientProvider`.
+ *
+ * @param host - The Lit reactive controller host that owns the mutation cache
+ * subscription.
+ * @param options - Mutation state filters and optional selector.
+ * @param queryClient - Optional explicit query client. Provide this for
+ * controllers that should not resolve a client from Lit context.
+ * @returns An accessor for the selected mutation state array.
+ *
+ * @example
+ * ```ts
+ * import { LitElement, html } from 'lit'
+ * import { useMutationState } from '@tanstack/lit-query'
+ *
+ * class PendingUploads extends LitElement {
+ *   private readonly uploads = useMutationState(this, {
+ *     filters: { mutationKey: ['upload'], status: 'pending' },
+ *     select: (mutation) => mutation.state.variables as File,
+ *   })
+ *
+ *   render() {
+ *     return html`<span>${this.uploads().length} uploads pending</span>`
+ *   }
+ * }
+ * ```
+ */
+declare function useMutationState<TResult = MutationState<unknown, unknown, unknown, unknown>>(host: ReactiveControllerHost, options?: MutationStateOptions<TResult>, queryClient?: QueryClient): MutationStateAccessor<TResult>;
+//#endregion
+//#region src/queryOptions.d.ts
+/**
+ * Query options with `initialData` that guarantees defined query data.
+ */
+type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryFn'> & {
+  initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+  queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
+};
+/**
+ * Query options where `queryFn` is present and not a `skipToken`.
+ */
+type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryFn'> & {
+  queryFn?: Exclude<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>['queryFn'], SkipToken | undefined>;
+};
+/**
+ * Query options where `initialData` can be omitted or undefined.
+ */
+type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+  initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
+};
+/**
+ * Brands query options so the `queryKey` carries the query function data and
+ * error types across TanStack Query APIs.
+ *
+ * @param options - Query options to preserve and brand.
+ * @returns The same options object with a typed `queryKey`.
+ *
+ * @example
+ * ```ts
+ * import { queryOptions } from '@tanstack/lit-query'
+ *
+ * const todosOptions = queryOptions({
+ *   queryKey: ['todos'],
+ *   queryFn: fetchTodos,
+ *   initialData: [],
+ * })
+ * ```
+ */
+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>;
+};
+/**
+ * Brands query options so the `queryKey` carries the query function data and
+ * error types across TanStack Query APIs.
+ *
+ * @param options - Query options to preserve and brand.
+ * @returns The same options object with a typed `queryKey`.
+ */
+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>;
+};
+/**
+ * Brands query options so the `queryKey` carries the query function data and
+ * error types across TanStack Query APIs.
+ *
+ * @param options - Query options to preserve and brand.
+ * @returns The same options object with a typed `queryKey`.
+ */
+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>;
+};
+//#endregion
+//#region src/infiniteQueryOptions.d.ts
+/**
+ * Brands infinite query options so the `queryKey` carries the infinite query
+ * data and error types across TanStack Query APIs.
+ *
+ * @param options - Infinite query options to preserve and brand.
+ * @returns The same options object with a typed `queryKey`.
+ *
+ * @example
+ * ```ts
+ * import { infiniteQueryOptions } from '@tanstack/lit-query'
+ *
+ * const projectsOptions = infiniteQueryOptions({
+ *   queryKey: ['projects'],
+ *   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextCursor,
+ * })
+ * ```
+ */
+declare function infiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+//#endregion
+//#region src/mutationOptions.d.ts
+/**
+ * Preserves and types mutation options for reuse across Lit Query APIs.
+ *
+ * @param options - Mutation options to preserve.
+ * @returns The same options object.
+ *
+ * @example
+ * ```ts
+ * import { mutationOptions } from '@tanstack/lit-query'
+ *
+ * const addTodoOptions = mutationOptions({
+ *   mutationKey: ['add-todo'],
+ *   mutationFn: (title: string) => addTodo(title),
+ * })
+ * ```
+ */
+declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>): MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Accessor-wrapped options accepted by `createQueryController`.
+ */
+type QueryControllerOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<CreateQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>;
+/**
+ * Result object produced by a Lit query controller.
+ */
+type QueryControllerResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+/**
+ * Accessor-wrapped options accepted by `createInfiniteQueryController`.
+ */
+type InfiniteQueryControllerOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
+/**
+ * Accessor-wrapped options accepted by `createMutationController`.
+ */
+type MutationControllerOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>>;
+/**
+ * Result object produced by a Lit mutation controller.
+ */
+type MutationControllerResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutationObserverResult<TData, TError, TVariables, TOnMutateResult>;
+/**
+ * Accessor-wrapped options accepted by `createQueriesController`.
+ */
+type QueriesControllerOptions<TQueryOptions extends Array<any> = Array<any>, TCombinedResult = CreateQueriesResults<TQueryOptions>> = Accessor<CreateQueriesControllerOptions<TQueryOptions, TCombinedResult>>;
+//#endregion
+export { type Accessor, type CreateInfiniteQueryOptions, type CreateMutationOptions, type CreateQueriesControllerOptions, type CreateQueriesInput, type CreateQueryOptions, type DefinedInitialDataOptions, type InfiniteQueryControllerOptions, type InfiniteQueryResultAccessor, type IsFetchingAccessor, type IsMutatingAccessor, type MutationControllerOptions, type MutationControllerResult, type MutationResultAccessor, type MutationStateAccessor, type MutationStateOptions, type QueriesControllerOptions, type QueriesResultAccessor, QueryClientProvider, type QueryControllerOptions, type QueryControllerResult, type QueryResultAccessor, type UndefinedInitialDataOptions, type UnusedSkipTokenOptions, type ValueAccessor, createInfiniteQueryController, createMutationController, createQueriesController, createQueryController, getDefaultQueryClient, infiniteQueryOptions, mutationOptions, queryClientContext, queryOptions, registerDefaultQueryClient, resolveQueryClient, unregisterDefaultQueryClient, useIsFetching, useIsMutating, useMutationState, useQueryClient };
+//# sourceMappingURL=index.d.ts.map