@codesocietyou/contentedge-cms-sdk 1.0.8 → 2.0.0

package/dist/index.d.cts

@@ -1,9 +1,7 @@
 import { AxiosInstance } from "axios";
-import * as _$_tanstack_react_query0 from "@tanstack/react-query";
 import { UseQueryResult } from "@tanstack/react-query";
-
 //#region src/types/config.d.ts
-interface SdkConfig {
+export interface SdkConfig {
   baseUrl: string;
   fileBaseUrl?: string;
   apiKey?: string;
@@ -20,37 +18,42 @@ interface SdkConfig {
 /**
  * Create and configure the API client with the given configuration
  */
-declare function createApiClient(config: SdkConfig): AxiosInstance;
+export declare function createApiClient(config: SdkConfig): AxiosInstance;
 /**
  * Get the current API client instance
  * Throws if not initialized
  */
-declare function getApiClient(): AxiosInstance;
+export declare function getApiClient(): AxiosInstance;
 /**
  * Reset the API client (useful for testing)
  */
-declare function resetApiClient(): void;
-declare const apiClient: AxiosInstance;
+export declare function resetApiClient(): void;
+export declare const apiClient: AxiosInstance;
 //#endregion
 //#region src/types/content.d.ts
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonValue[] | {
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
   [key: string]: JsonValue;
 };
-type CustomFields = Record<string, JsonValue>;
-interface ContentDto<C extends CustomFields = CustomFields> {
+export type CustomFields = Record<string, JsonValue>;
+export interface ContentDto<C extends CustomFields = CustomFields> {
   id: number;
   title: string;
   text: string;
   type: string;
   customFields: C;
+  /**
+   * Per-type admin display order. Lower values appear first.
+   * Not unique: concurrent creates can share a value; the CMS uses id ASC as a tie-breaker.
+   */
+  sortOrder?: number;
 }
-interface ApiResponse<T> {
+export interface ApiResponse<T> {
   status: 'SUCCESS' | 'FAILURE';
   message: string;
   data: T;
 }
-interface PaginatedData<T> {
+export interface PaginatedData<T> {
   content: T[];
   number?: number;
   size?: number;
@@ -63,12 +66,20 @@ interface PaginatedData<T> {
   sort?: unknown;
   pageable?: unknown;
 }
-type ContentResponse<C extends CustomFields = CustomFields> = ApiResponse<PaginatedData<ContentDto<C>>>;
-interface ContentListParams {
+export type ContentResponse<C extends CustomFields = CustomFields> = ApiResponse<PaginatedData<ContentDto<C>>>;
+export interface ContentListParams {
   type?: string;
   page?: number;
   size?: number;
+  /**
+   * Sort field forwarded to the CMS (`id` or `sortOrder`).
+   * Omit to follow the admin display order. Pass `"id"` to ignore it.
+   */
   sortBy?: string;
+  /**
+   * Sort direction forwarded to the CMS.
+   * Omit with `sortBy` to use the CMS default (`ASC` when sorting by `sortOrder`).
+   */
   direction?: 'ASC' | 'DESC';
   filters?: Record<string, string | number | boolean | null | undefined>;
 }
@@ -77,7 +88,7 @@ interface ContentListParams {
  * This type is exported for convenience but normalization is handled
  * by the {@link normalizeContentItem} function in utils/normalization.
  */
-interface NormalizedContentItem {
+export interface NormalizedContentItem {
   id: number;
   title: string;
   /**
@@ -111,26 +122,31 @@ interface NormalizedContentItem {
   team: string | null;
   publicationType: string | null;
   fake: boolean | null;
+  /**
+   * Per-type admin display order. Lower values appear first.
+   * Omitted when the API did not send `sortOrder`.
+   */
+  sortOrder?: number;
 }
 //#endregion
 //#region src/services/contentApi.d.ts
 /**
  * Fetch content by type with pagination and filters
  */
-declare function fetchContentByType<C extends CustomFields = CustomFields>(params?: ContentListParams): Promise<ContentResponse<C>>;
+export declare function fetchContentByType<C extends CustomFields = CustomFields>(params?: ContentListParams): Promise<ContentResponse<C>>;
 /**
  * Fetch a single content item by ID
  */
-declare function fetchContentById<C extends CustomFields = CustomFields>(id: number): Promise<ApiResponse<ContentDto<C>>>;
+export declare function fetchContentById<C extends CustomFields = CustomFields>(id: number): Promise<ApiResponse<ContentDto<C>>>;
 /**
  * Download a file from a given path
  * @param path - Full URL or relative path to the file
  * @returns Blob containing the file data
  */
-declare function downloadFile(path: string): Promise<Blob>;
+export declare function downloadFile(path: string): Promise<Blob>;
 //#endregion
 //#region src/services/contentFetchAll.d.ts
-interface FetchAllOptions<C extends CustomFields, T> {
+export interface FetchAllOptions<C extends CustomFields, T> {
   /**
    * Optional function to transform each content item
    */
@@ -158,83 +174,87 @@ interface FetchAllOptions<C extends CustomFields, T> {
  * @param options - Fetch options including mapping and deduplication
  * @returns Array of all fetched items
  */
-declare function fetchAllContent<C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, 'page'> & {
+export declare function fetchAllContent<C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, 'page'> & {
   page?: never;
 }, options?: FetchAllOptions<C, T>): Promise<T[]>;
 //#endregion
-//#region node_modules/@tanstack/query-core/build/modern/_tsup-dts-rollup.d.ts
-declare type Action<TData, TError, TVariables, TOnMutateResult> = ContinueAction_2 | ErrorAction_2<TError> | FailedAction_2<TError> | PendingAction<TVariables, TOnMutateResult> | PauseAction_2 | SuccessAction_2<TData>;
-declare type Action_alias_1<TData, TError> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | FetchAction | InvalidateAction | PauseAction | SetStateAction<TData, TError> | SuccessAction<TData>;
-declare type AnyDataTag = {
-  [dataTagSymbol$1]: any;
-  [dataTagErrorSymbol$1]: any;
-};
-declare interface CancelOptions {
-  revert?: boolean;
-  silent?: boolean;
-}
-declare interface ContinueAction {
-  type: 'continue';
-}
-declare interface ContinueAction_2 {
-  type: 'continue';
-}
-declare type DataTag<TType, TValue, TError = UnsetMarker> = TType extends AnyDataTag ? TType : TType & {
-  [dataTagSymbol$1]: TValue;
-  [dataTagErrorSymbol$1]: TError;
-};
-declare const dataTagErrorSymbol$1: unique symbol;
-declare type dataTagErrorSymbol$1 = typeof dataTagErrorSymbol$1;
-declare const dataTagSymbol$1: unique symbol;
-declare type dataTagSymbol$1 = typeof dataTagSymbol$1;
-declare type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwOnError' | 'refetchOnReconnect' | 'queryHash'>;
-declare type DefaultError = Register extends {
-  defaultError: infer TError;
-} ? TError : Error;
-declare interface DefaultOptions<TError = DefaultError> {
-  queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'suspense' | 'queryKey'>;
-  mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
-  hydrate?: HydrateOptions['defaultOptions'];
-  dehydrate?: DehydrateOptions;
-}
-declare type DefinedInfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
-declare type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
-declare interface DehydrateOptions {
-  serializeData?: TransformerFn;
-  shouldDehydrateMutation?: (mutation: Mutation) => boolean;
-  shouldDehydrateQuery?: (query: Query) => boolean;
-  shouldRedactErrors?: (error: unknown) => boolean;
+//#region node_modules/@tanstack/query-core/build/modern/subscribable-CbifVTKz.d.ts
+//#region src/subscribable.d.ts
+declare class Subscribable<TListener extends Function> {
+  protected listeners: Set<TListener>;
+  constructor();
+  subscribe(listener: TListener): () => void;
+  hasListeners(): boolean;
+  protected onSubscribe(): void;
+  protected onUnsubscribe(): void;
 }
-declare type DropLast<T extends ReadonlyArray<unknown>> = T extends readonly [...infer R, unknown] ? readonly [...R] : never;
-declare type EnsureInfiniteQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-  revalidateIfStale?: boolean;
-};
-declare interface EnsureQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> {
-  revalidateIfStale?: boolean;
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/removable-DeMjhW5M.d.ts
+//#region src/removable.d.ts
+declare abstract class Removable {
+  #private;
+  gcTime: number;
+  destroy(): void;
+  protected scheduleGc(): void;
+  protected updateGcTime(newGcTime: number | undefined): void;
+  protected clearGcTimeout(): void;
+  protected abstract optionalRemove(): void;
 }
-declare interface ErrorAction<TError> {
-  type: 'error';
-  error: TError;
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/hydration-Bjs0MSgg.d.ts
+//#region src/queryObserver.d.ts
+type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
+interface ObserverFetchOptions extends FetchOptions {
+  throwOnError?: boolean;
 }
-declare interface ErrorAction_2<TError> {
-  type: 'error';
-  error: TError;
+declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Subscribable<QueryObserverListener<TData, TError>> {
+  #private;
+  options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+  constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+  protected bindMethods(): void;
+  protected onSubscribe(): void;
+  protected onUnsubscribe(): void;
+  shouldFetchOnReconnect(): boolean;
+  shouldFetchOnWindowFocus(): boolean;
+  destroy(): void;
+  setOptions(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): void;
+  getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+  getCurrentResult(): QueryObserverResult<TData, TError>;
+  trackResult(result: QueryObserverResult<TData, TError>, onPropTracked?: (key: keyof QueryObserverResult) => void): QueryObserverResult<TData, TError>;
+  trackProp(key: keyof QueryObserverResult): void;
+  getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+  refetch({ ...options }?: RefetchOptions): Promise<QueryObserverResult<TData, TError>>;
+  fetchOptimistic(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
+  protected fetch(fetchOptions: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
+  protected createResult(query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+  updateResult(): void;
+  onQueryUpdate(): void;
 }
-declare interface FailedAction<TError> {
-  type: 'failed';
-  failureCount: number;
-  error: TError;
+//#endregion
+//#region src/query.d.ts
+interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+  client: QueryClient;
+  queryKey: TQueryKey;
+  queryHash: string;
+  options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+  defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+  state?: QueryState<TData, TError>;
 }
-declare interface FailedAction_2<TError> {
-  type: 'failed';
-  failureCount: number;
+interface QueryState<TData = unknown, TError = DefaultError> {
+  data: TData | undefined;
+  dataUpdateCount: number;
+  dataUpdatedAt: number;
   error: TError | null;
+  errorUpdateCount: number;
+  errorUpdatedAt: number;
+  fetchFailureCount: number;
+  fetchFailureReason: TError | null;
+  fetchMeta: FetchMeta | null;
+  isInvalidated: boolean;
+  status: QueryStatus;
+  fetchStatus: FetchStatus;
 }
-declare interface FetchAction {
-  type: 'fetch';
-  meta?: FetchMeta;
-}
-declare interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
   fetchFn: () => unknown | Promise<unknown>;
   fetchOptions?: FetchOptions;
   signal: AbortSignal;
@@ -243,216 +263,142 @@ declare interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends Qu
   queryKey: TQueryKey;
   state: QueryState<TData, TError>;
 }
-declare type FetchDirection = 'forward' | 'backward';
-declare type FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Omit<FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData, TPageParam>, TQueryKey, TPageParam>, 'initialPageParam'> & InitialPageParam<TPageParam> & FetchInfiniteQueryPages<TQueryFnData, TPageParam>;
-declare type FetchInfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> = {
-  pages?: never;
-} | {
-  pages: number;
-  getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
-};
-declare interface FetchMeta {
+interface QueryBehavior<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+  onFetch: (context: FetchContext<TQueryFnData, TError, TData, TQueryKey>, query: Query) => void;
+}
+type FetchDirection = 'forward' | 'backward';
+interface FetchMeta {
   fetchMore?: {
     direction: FetchDirection;
   };
 }
-declare interface FetchNextPageOptions extends ResultOptions {
-  /**
-   * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,
-   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
-   *
-   * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.
-   *
-   * Defaults to `true`.
-   */
-  cancelRefetch?: boolean;
-}
-declare interface FetchOptions<TData = unknown> {
+interface FetchOptions<TData = unknown> {
   cancelRefetch?: boolean;
   meta?: FetchMeta;
   initialPromise?: Promise<TData>;
 }
-declare interface FetchPreviousPageOptions extends ResultOptions {
-  /**
-   * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,
-   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
-   *
-   * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.
-   *
-   * Defaults to `true`.
-   */
-  cancelRefetch?: boolean;
-}
-declare interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'> {
-  initialPageParam?: never;
-  /**
-   * The time in milliseconds after data is considered stale.
-   * If the data is fresh it will be returned from the cache.
-   */
-  staleTime?: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>;
-}
-declare type FetchStatus = 'fetching' | 'paused' | 'idle';
-declare type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: Array<TQueryFnData>, lastPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
-declare interface HydrateOptions {
-  defaultOptions?: {
-    deserializeData?: TransformerFn;
-    queries?: QueryOptions;
-    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>;
-  };
+interface FailedAction$1<TError> {
+  type: 'failed';
+  failureCount: number;
+  error: TError;
 }
-declare type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown> ? TaggedValue : TQueryFnData;
-declare type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError> ? TaggedError extends UnsetMarker ? TError : TaggedError : TError;
-declare interface InfiniteData<TData, TPageParam = unknown> {
-  pages: Array<TData>;
-  pageParams: Array<TPageParam>;
+interface FetchAction {
+  type: 'fetch';
+  meta?: FetchMeta;
 }
-declare interface InfiniteQueryObserverBaseResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
-  /**
-   * This function allows you to fetch the next "page" of results.
-   */
-  fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
-  /**
-   * This function allows you to fetch the previous "page" of results.
-   */
-  fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
-  /**
-   * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
-   */
-  hasNextPage: boolean;
-  /**
-   * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
-   */
-  hasPreviousPage: boolean;
-  /**
-   * Will be `true` if the query failed while fetching the next page.
-   */
-  isFetchNextPageError: boolean;
-  /**
-   * Will be `true` while fetching the next page with `fetchNextPage`.
-   */
-  isFetchingNextPage: boolean;
-  /**
-   * Will be `true` if the query failed while fetching the previous page.
-   */
-  isFetchPreviousPageError: boolean;
-  /**
-   * Will be `true` while fetching the previous page with `fetchPreviousPage`.
-   */
-  isFetchingPreviousPage: boolean;
+interface SuccessAction$1<TData> {
+  data: TData | undefined;
+  type: 'success';
+  dataUpdatedAt?: number;
+  manual?: boolean;
 }
-declare interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
-  data: undefined;
+interface ErrorAction$1<TError> {
+  type: 'error';
   error: TError;
-  isError: true;
-  isPending: false;
-  isLoading: false;
-  isLoadingError: true;
-  isRefetchError: false;
-  isFetchNextPageError: false;
-  isFetchPreviousPageError: false;
-  isSuccess: false;
-  isPlaceholderData: false;
-  status: 'error';
 }
-declare interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
-  data: undefined;
-  error: null;
-  isError: false;
-  isPending: true;
-  isLoading: true;
-  isLoadingError: false;
-  isRefetchError: false;
-  isFetchNextPageError: false;
-  isFetchPreviousPageError: false;
-  isSuccess: false;
-  isPlaceholderData: false;
-  status: 'pending';
+interface InvalidateAction {
+  type: 'invalidate';
 }
-declare interface InfiniteQueryObserverPendingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
-  data: undefined;
-  error: null;
-  isError: false;
-  isPending: true;
-  isLoadingError: false;
-  isRefetchError: false;
-  isFetchNextPageError: false;
-  isFetchPreviousPageError: false;
-  isSuccess: false;
-  isPlaceholderData: false;
-  status: 'pending';
+interface PauseAction$1 {
+  type: 'pause';
 }
-declare interface InfiniteQueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
-  data: TData;
-  isError: false;
-  error: null;
-  isPending: false;
-  isLoading: false;
-  isLoadingError: false;
-  isRefetchError: false;
-  isSuccess: true;
-  isPlaceholderData: true;
-  isFetchNextPageError: false;
-  isFetchPreviousPageError: false;
-  status: 'success';
+interface ContinueAction$1 {
+  type: 'continue';
 }
-declare interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
-  data: TData;
-  error: TError;
-  isError: true;
-  isPending: false;
-  isLoading: false;
-  isLoadingError: false;
-  isRefetchError: true;
-  isSuccess: false;
-  isPlaceholderData: false;
-  status: 'error';
+interface SetStateAction<TData, TError> {
+  type: 'setState';
+  state: Partial<QueryState<TData, TError>>;
 }
-declare type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError> | InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverPendingResult<TData, TError> | InfiniteQueryObserverPlaceholderResult<TData, TError>;
-declare interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
-  data: TData;
-  error: null;
-  isError: false;
-  isPending: false;
-  isLoading: false;
-  isLoadingError: false;
-  isRefetchError: false;
-  isFetchNextPageError: false;
-  isFetchPreviousPageError: false;
-  isSuccess: true;
-  isPlaceholderData: false;
-  status: 'success';
+type Action$1<TData, TError> = ContinueAction$1 | ErrorAction$1<TError> | FailedAction$1<TError> | FetchAction | InvalidateAction | PauseAction$1 | SetStateAction<TData, TError> | SuccessAction$1<TData>;
+declare class Query<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Removable {
+  #private;
+  queryKey: TQueryKey;
+  queryHash: string;
+  options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+  state: QueryState<TData, TError>;
+  observers: Array<QueryObserver<any, any, any, any, any>>;
+  constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);
+  get meta(): QueryMeta | undefined;
+  get queryType(): "infinite" | undefined;
+  get promise(): Promise<TData> | undefined;
+  setOptions(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): void;
+  protected optionalRemove(): void;
+  setData(newData: TData, options?: SetDataOptions & {
+    manual: boolean;
+  }): TData;
+  setState(state: Partial<QueryState<TData, TError>>): void;
+  cancel(options?: CancelOptions): Promise<void>;
+  destroy(): void;
+  get resetState(): QueryState<TData, TError>;
+  reset(): void;
+  isActive(): boolean;
+  isDisabled(): boolean;
+  isFetched(): boolean;
+  isStatic(): boolean;
+  isStale(): boolean;
+  isStaleByTime(staleTime?: StaleTime): boolean;
+  onFocus(): void;
+  onOnline(): void;
+  addObserver(observer: QueryObserver<any, any, any, any, any>): void;
+  removeObserver(observer: QueryObserver<any, any, any, any, any>): void;
+  getObserversCount(): number;
+  invalidate(): void;
+  fetch(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, fetchOptions?: FetchOptions<TQueryFnData>): Promise<TData>;
 }
-declare type InitialDataFunction<T> = () => T | undefined;
-declare interface InitialPageParam<TPageParam = unknown> {
-  initialPageParam: TPageParam;
+//#endregion
+//#region src/mutationObserver.d.ts
+type MutationObserverListener<TData, TError, TVariables, TOnMutateResult> = (result: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>) => void;
+declare class MutationObserver<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends Subscribable<MutationObserverListener<TData, TError, TVariables, TOnMutateResult>> {
+  #private;
+  options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
+  constructor(client: QueryClient, options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>);
+  protected bindMethods(): void;
+  setOptions(options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>): void;
+  protected onSubscribe(): void;
+  protected onUnsubscribe(): void;
+  onMutationUpdate(action: Action<TData, TError, TVariables, TOnMutateResult>): void;
+  getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TOnMutateResult>;
+  reset(): void;
+  mutate(variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>): Promise<TData>;
 }
-declare interface InvalidateAction {
-  type: 'invalidate';
+//#endregion
+//#region src/mutationCache.d.ts
+interface MutationCacheConfig {
+  onError?: (error: DefaultError, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onSuccess?: (data: unknown, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onSettled?: (data: unknown | undefined, error: DefaultError | null, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
 }
-declare interface InvalidateOptions extends RefetchOptions {}
-declare interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {
-  refetchType?: QueryTypeFilter | 'none';
+interface NotifyEventMutationAdded extends NotifyEvent {
+  type: 'added';
+  mutation: Mutation<any, any, any, any>;
 }
-declare type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>) => Promise<TData>;
-declare interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
-  onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
-  onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
-  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+interface NotifyEventMutationRemoved extends NotifyEvent {
+  type: 'removed';
+  mutation: Mutation<any, any, any, any>;
 }
-declare class Mutation<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> extends Removable {
-  #private;
-  state: MutationState<TData, TError, TVariables, TOnMutateResult>;
-  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
-  readonly mutationId: number;
-  constructor(config: MutationConfig<TData, TError, TVariables, TOnMutateResult>);
-  setOptions(options: MutationOptions<TData, TError, TVariables, TOnMutateResult>): void;
-  get meta(): MutationMeta | undefined;
-  addObserver(observer: MutationObserver_2<any, any, any, any>): void;
-  removeObserver(observer: MutationObserver_2<any, any, any, any>): void;
-  protected optionalRemove(): void;
-  continue(): Promise<unknown>;
-  execute(variables: TVariables): Promise<TData>;
+interface NotifyEventMutationObserverAdded extends NotifyEvent {
+  type: 'observerAdded';
+  mutation: Mutation<any, any, any, any>;
+  observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverRemoved extends NotifyEvent {
+  type: 'observerRemoved';
+  mutation: Mutation<any, any, any, any>;
+  observer: MutationObserver<any, any, any>;
 }
+interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
+  type: 'observerOptionsUpdated';
+  mutation?: Mutation<any, any, any, any>;
+  observer: MutationObserver<any, any, any, any>;
+}
+interface NotifyEventMutationUpdated extends NotifyEvent {
+  type: 'updated';
+  mutation: Mutation<any, any, any, any>;
+  action: Action<any, any, any, any>;
+}
+type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationObserverOptionsUpdated | NotifyEventMutationUpdated;
+type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;
 declare class MutationCache extends Subscribable<MutationCacheListener> {
   #private;
   config: MutationCacheConfig;
@@ -469,321 +415,159 @@ declare class MutationCache extends Subscribable<MutationCacheListener> {
   notify(event: MutationCacheNotifyEvent): void;
   resumePausedMutations(): Promise<unknown>;
 }
-declare interface MutationCacheConfig {
-  onError?: (error: DefaultError, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
-  onSuccess?: (data: unknown, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
-  onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
-  onSettled?: (data: unknown | undefined, error: DefaultError | null, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
-}
-declare type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;
-declare type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationObserverOptionsUpdated | NotifyEventMutationUpdated;
-declare interface MutationConfig<TData, TError, TVariables, TOnMutateResult> {
+//#endregion
+//#region src/mutation.d.ts
+interface MutationConfig<TData, TError, TVariables, TOnMutateResult> {
   client: QueryClient;
   mutationId: number;
   mutationCache: MutationCache;
   options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
   state?: MutationState<TData, TError, TVariables, TOnMutateResult>;
 }
-declare interface MutationFilters<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
-  /**
-   * Match mutation key exactly
-   */
-  exact?: boolean;
-  /**
-   * Include mutations matching this predicate function
-   */
-  predicate?: (mutation: Mutation<TData, TError, TVariables, TOnMutateResult>) => boolean;
-  /**
-   * Include mutations matching this mutation key
-   */
-  mutationKey?: TuplePrefixes<MutationKey>;
-  /**
-   * Filter by mutation status
-   */
-  status?: MutationStatus;
+interface MutationState<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
+  context: TOnMutateResult | undefined;
+  data: TData | undefined;
+  error: TError | null;
+  failureCount: number;
+  failureReason: TError | null;
+  isPaused: boolean;
+  status: MutationStatus;
+  variables: TVariables | undefined;
+  submittedAt: number;
 }
-declare type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables, context: MutationFunctionContext) => Promise<TData>;
-declare type MutationFunctionContext = {
-  client: QueryClient;
-  meta: MutationMeta | undefined;
-  mutationKey?: MutationKey;
-};
-declare type MutationKey = Register extends {
-  mutationKey: infer TMutationKey;
-} ? TMutationKey extends ReadonlyArray<unknown> ? TMutationKey : TMutationKey extends Array<unknown> ? TMutationKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
-declare type MutationMeta = Register extends {
-  mutationMeta: infer TMutationMeta;
-} ? TMutationMeta extends Record<string, unknown> ? TMutationMeta : Record<string, unknown> : Record<string, unknown>;
-declare class MutationObserver_2<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends Subscribable<MutationObserverListener<TData, TError, TVariables, TOnMutateResult>> {
+interface FailedAction<TError> {
+  type: 'failed';
+  failureCount: number;
+  error: TError | null;
+}
+interface PendingAction<TVariables, TOnMutateResult> {
+  type: 'pending';
+  isPaused: boolean;
+  variables?: TVariables;
+  context?: TOnMutateResult;
+}
+interface SuccessAction<TData> {
+  type: 'success';
+  data: TData;
+}
+interface ErrorAction<TError> {
+  type: 'error';
+  error: TError;
+}
+interface PauseAction {
+  type: 'pause';
+}
+interface ContinueAction {
+  type: 'continue';
+}
+type Action<TData, TError, TVariables, TOnMutateResult> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | PendingAction<TVariables, TOnMutateResult> | PauseAction | SuccessAction<TData>;
+declare class Mutation<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> extends Removable {
   #private;
-  options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
-  constructor(client: QueryClient, options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>);
-  protected bindMethods(): void;
-  setOptions(options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>): void;
-  protected onUnsubscribe(): void;
-  onMutationUpdate(action: Action<TData, TError, TVariables, TOnMutateResult>): void;
-  getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TOnMutateResult>;
-  reset(): void;
-  mutate(variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>): Promise<TData>;
+  state: MutationState<TData, TError, TVariables, TOnMutateResult>;
+  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  readonly mutationId: number;
+  constructor(config: MutationConfig<TData, TError, TVariables, TOnMutateResult>);
+  setOptions(options: MutationOptions<TData, TError, TVariables, TOnMutateResult>): void;
+  get meta(): MutationMeta | undefined;
+  addObserver(observer: MutationObserver<any, any, any, any>): void;
+  removeObserver(observer: MutationObserver<any, any, any, any>): void;
+  protected optionalRemove(): void;
+  continue(): Promise<unknown>;
+  execute(variables: TVariables): Promise<TData>;
 }
-declare interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationState<TData, TError, TVariables, TOnMutateResult> {
-  /**
-   * The last successfully resolved data for the mutation.
-   */
-  data: TData | undefined;
+//#endregion
+//#region src/utils.d.ts
+type DropLast<T extends ReadonlyArray<unknown>> = T extends readonly [...infer R, unknown] ? readonly [...R] : never;
+type TuplePrefixes<T extends ReadonlyArray<unknown>> = T extends readonly [] ? readonly [] : TuplePrefixes<DropLast<T>> | T;
+interface QueryFilters<TQueryKey extends QueryKey = QueryKey> {
   /**
-   * The variables object passed to the `mutationFn`.
+   * Filter to active queries, inactive queries or all queries
    */
-  variables: TVariables | undefined;
+  type?: QueryTypeFilter;
   /**
-   * The error object for the mutation, if an error was encountered.
-   * - Defaults to `null`.
+   * Match query key exactly
    */
-  error: TError | null;
+  exact?: boolean;
   /**
-   * A boolean variable derived from `status`.
-   * - `true` if the last mutation attempt resulted in an error.
+   * Include queries matching this predicate function
    */
-  isError: boolean;
+  predicate?: (query: Query) => boolean;
   /**
-   * A boolean variable derived from `status`.
-   * - `true` if the mutation is in its initial state prior to executing.
+   * Include queries matching this query key
    */
-  isIdle: boolean;
+  queryKey?: TQueryKey | TuplePrefixes<TQueryKey>;
   /**
-   * A boolean variable derived from `status`.
-   * - `true` if the mutation is currently executing.
+   * Include or exclude stale queries
    */
-  isPending: boolean;
+  stale?: boolean;
   /**
-   * A boolean variable derived from `status`.
-   * - `true` if the last mutation attempt was successful.
+   * Include queries matching their fetchStatus
    */
-  isSuccess: boolean;
+  fetchStatus?: FetchStatus;
+}
+interface MutationFilters<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
   /**
-   * The status of the mutation.
-   * - Will be:
-   *   - `idle` initial status prior to the mutation function executing.
-   *   - `pending` if the mutation is currently executing.
-   *   - `error` if the last mutation attempt resulted in an error.
-   *   - `success` if the last mutation attempt was successful.
+   * Match mutation key exactly
    */
-  status: MutationStatus;
+  exact?: boolean;
   /**
-   * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
-   * @param variables - The variables object to pass to the `mutationFn`.
-   * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.
-   * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.
-   * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
-   * @remarks
-   * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
-   * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
+   * Include mutations matching this predicate function
    */
-  mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+  predicate?: (mutation: Mutation<TData, TError, TVariables, TOnMutateResult>) => boolean;
   /**
-   * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
+   * Include mutations matching this mutation key
    */
-  reset: () => void;
-}
-declare interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
-  data: undefined;
-  error: TError;
-  variables: TVariables;
-  isError: true;
-  isIdle: false;
-  isPending: false;
-  isSuccess: false;
-  status: 'error';
-}
-declare interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
-  data: undefined;
-  variables: undefined;
-  error: null;
-  isError: false;
-  isIdle: true;
-  isPending: false;
-  isSuccess: false;
-  status: 'idle';
-}
-declare type MutationObserverListener<TData, TError, TVariables, TOnMutateResult> = (result: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>) => void;
-declare interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
-  data: undefined;
-  variables: TVariables;
-  error: null;
-  isError: false;
-  isIdle: false;
-  isPending: true;
-  isSuccess: false;
-  status: 'pending';
-}
-declare interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {
-  throwOnError?: boolean | ((error: TError) => boolean);
-}
-declare type MutationObserverResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverLoadingResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverErrorResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverSuccessResult<TData, TError, TVariables, TOnMutateResult>;
-declare interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
-  data: TData;
-  error: null;
-  variables: TVariables;
-  isError: false;
-  isIdle: false;
-  isPending: false;
-  isSuccess: true;
-  status: 'success';
-}
-declare interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
-  mutationFn?: MutationFunction<TData, TVariables>;
-  mutationKey?: MutationKey;
-  onMutate?: (variables: TVariables, context: MutationFunctionContext) => Promise<TOnMutateResult> | TOnMutateResult;
-  onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => Promise<unknown> | unknown;
-  onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
-  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
-  retry?: RetryValue<TError>;
-  retryDelay?: RetryDelayValue<TError>;
-  networkMode?: NetworkMode;
-  gcTime?: number;
-  _defaulted?: boolean;
-  meta?: MutationMeta;
-  scope?: MutationScope;
-}
-declare type MutationScope = {
-  id: string;
-};
-declare interface MutationState<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
-  context: TOnMutateResult | undefined;
-  data: TData | undefined;
-  error: TError | null;
-  failureCount: number;
-  failureReason: TError | null;
-  isPaused: boolean;
-  status: MutationStatus;
-  variables: TVariables | undefined;
-  submittedAt: number;
-}
-declare type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
-declare type NetworkMode = 'online' | 'always' | 'offlineFirst';
-declare type NoInfer_2<T> = [T][T extends any ? 0 : never];
-declare type NonFunctionGuard<T> = T extends Function ? never : T;
-declare interface NotifyEvent {
-  type: NotifyEventType;
-}
-declare interface NotifyEventMutationAdded extends NotifyEvent {
-  type: 'added';
-  mutation: Mutation<any, any, any, any>;
-}
-declare interface NotifyEventMutationObserverAdded extends NotifyEvent {
-  type: 'observerAdded';
-  mutation: Mutation<any, any, any, any>;
-  observer: MutationObserver_2<any, any, any>;
-}
-declare interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
-  type: 'observerOptionsUpdated';
-  mutation?: Mutation<any, any, any, any>;
-  observer: MutationObserver_2<any, any, any, any>;
-}
-declare interface NotifyEventMutationObserverRemoved extends NotifyEvent {
-  type: 'observerRemoved';
-  mutation: Mutation<any, any, any, any>;
-  observer: MutationObserver_2<any, any, any>;
-}
-declare interface NotifyEventMutationRemoved extends NotifyEvent {
-  type: 'removed';
-  mutation: Mutation<any, any, any, any>;
-}
-declare interface NotifyEventMutationUpdated extends NotifyEvent {
-  type: 'updated';
-  mutation: Mutation<any, any, any, any>;
-  action: Action<any, any, any, any>;
-}
-declare interface NotifyEventQueryAdded extends NotifyEvent {
-  type: 'added';
-  query: Query<any, any, any, any>;
-}
-declare interface NotifyEventQueryObserverAdded extends NotifyEvent {
-  type: 'observerAdded';
-  query: Query<any, any, any, any>;
-  observer: QueryObserver<any, any, any, any, any>;
-}
-declare interface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {
-  type: 'observerOptionsUpdated';
-  query: Query<any, any, any, any>;
-  observer: QueryObserver<any, any, any, any, any>;
-}
-declare interface NotifyEventQueryObserverRemoved extends NotifyEvent {
-  type: 'observerRemoved';
-  query: Query<any, any, any, any>;
-  observer: QueryObserver<any, any, any, any, any>;
-}
-declare interface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {
-  type: 'observerResultsUpdated';
-  query: Query<any, any, any, any>;
-}
-declare interface NotifyEventQueryRemoved extends NotifyEvent {
-  type: 'removed';
-  query: Query<any, any, any, any>;
-}
-declare interface NotifyEventQueryUpdated extends NotifyEvent {
-  type: 'updated';
-  query: Query<any, any, any, any>;
-  action: Action_alias_1<any, any>;
-}
-declare type NotifyEventType = 'added' | 'removed' | 'updated' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
-declare type NotifyOnChangeProps = Array<keyof InfiniteQueryObserverResult> | 'all' | undefined | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined);
-declare interface ObserverFetchOptions extends FetchOptions {
-  throwOnError?: boolean;
-}
-declare type OmitKeyof<TObject, TKey extends (TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject), TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
-declare interface PauseAction {
-  type: 'pause';
-}
-declare interface PauseAction_2 {
-  type: 'pause';
-}
-declare interface PendingAction<TVariables, TOnMutateResult> {
-  type: 'pending';
-  isPaused: boolean;
-  variables?: TVariables;
-  context?: TOnMutateResult;
-}
-declare type PlaceholderDataFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (previousData: TQueryData | undefined, previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => TQueryData | undefined;
-declare class Query<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Removable {
-  #private;
-  queryKey: TQueryKey;
-  queryHash: string;
-  options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
-  state: QueryState<TData, TError>;
-  observers: Array<QueryObserver<any, any, any, any, any>>;
-  constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);
-  get meta(): QueryMeta | undefined;
-  get queryType(): "infinite" | undefined;
-  get promise(): Promise<TData> | undefined;
-  setOptions(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): void;
-  protected optionalRemove(): void;
-  setData(newData: TData, options?: SetDataOptions & {
-    manual: boolean;
-  }): TData;
-  setState(state: Partial<QueryState<TData, TError>>): void;
-  cancel(options?: CancelOptions): Promise<void>;
-  destroy(): void;
-  get resetState(): QueryState<TData, TError>;
-  reset(): void;
-  isActive(): boolean;
-  isDisabled(): boolean;
-  isFetched(): boolean;
-  isStatic(): boolean;
-  isStale(): boolean;
-  isStaleByTime(staleTime?: StaleTime): boolean;
-  onFocus(): void;
-  onOnline(): void;
-  addObserver(observer: QueryObserver<any, any, any, any, any>): void;
-  removeObserver(observer: QueryObserver<any, any, any, any, any>): void;
-  getObserversCount(): number;
-  invalidate(): void;
-  fetch(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, fetchOptions?: FetchOptions<TQueryFnData>): Promise<TData>;
+  mutationKey?: TuplePrefixes<MutationKey>;
+  /**
+   * Filter by mutation status
+   */
+  status?: MutationStatus;
 }
-declare interface QueryBehavior<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
-  onFetch: (context: FetchContext<TQueryFnData, TError, TData, TQueryKey>, query: Query) => void;
+type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
+type QueryTypeFilter = 'all' | 'active' | 'inactive';
+declare const skipToken: unique symbol;
+type SkipToken = typeof skipToken;
+//#endregion
+//#region src/queryCache.d.ts
+interface QueryCacheConfig {
+  onError?: (error: DefaultError, query: Query<unknown, unknown, unknown>) => void;
+  onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
+  onSettled?: (data: unknown | undefined, error: DefaultError | null, query: Query<unknown, unknown, unknown>) => void;
+}
+interface NotifyEventQueryAdded extends NotifyEvent {
+  type: 'added';
+  query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryRemoved extends NotifyEvent {
+  type: 'removed';
+  query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryUpdated extends NotifyEvent {
+  type: 'updated';
+  query: Query<any, any, any, any>;
+  action: Action$1<any, any>;
+}
+interface NotifyEventQueryObserverAdded extends NotifyEvent {
+  type: 'observerAdded';
+  query: Query<any, any, any, any>;
+  observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverRemoved extends NotifyEvent {
+  type: 'observerRemoved';
+  query: Query<any, any, any, any>;
+  observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {
+  type: 'observerResultsUpdated';
+  query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {
+  type: 'observerOptionsUpdated';
+  query: Query<any, any, any, any>;
+  observer: QueryObserver<any, any, any, any, any>;
 }
-declare type QueryBooleanOption<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = boolean | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean);
+type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated | NotifyEventQueryObserverOptionsUpdated;
+type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
 declare class QueryCache extends Subscribable<QueryCacheListener> {
   #private;
   config: QueryCacheConfig;
@@ -800,13 +584,8 @@ declare class QueryCache extends Subscribable<QueryCacheListener> {
   onFocus(): void;
   onOnline(): void;
 }
-declare interface QueryCacheConfig {
-  onError?: (error: DefaultError, query: Query<unknown, unknown, unknown>) => void;
-  onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
-  onSettled?: (data: unknown | undefined, error: DefaultError | null, query: Query<unknown, unknown, unknown>) => void;
-}
-declare type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
-declare type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated | NotifyEventQueryObserverOptionsUpdated;
+//#endregion
+//#region src/queryClient.d.ts
 declare class QueryClient {
   #private;
   constructor(config?: QueryClientConfig);
@@ -822,20 +601,40 @@ declare class QueryClient {
    * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
    */
   getQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined;
+  /**
+   * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
+   */
   ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
   getQueriesData<TQueryFnData = unknown, TQueryFilters extends QueryFilters<any> = QueryFilters>(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | 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?: SetDataOptions): NoInfer_2<TInferredQueryFnData> | undefined;
-  setQueriesData<TQueryFnData, TQueryFilters extends QueryFilters<any> = QueryFilters>(filters: TQueryFilters, updater: Updater<NoInfer_2<TQueryFnData> | undefined, NoInfer_2<TQueryFnData> | undefined>, options?: SetDataOptions): Array<[QueryKey, TQueryFnData | undefined]>;
+  setQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey, updater: Updater<NoInfer<TInferredQueryFnData> | undefined, NoInfer<TInferredQueryFnData> | undefined>, options?: SetDataOptions): NoInfer<TInferredQueryFnData> | undefined;
+  setQueriesData<TQueryFnData, TQueryFilters extends QueryFilters<any> = QueryFilters>(filters: TQueryFilters, updater: Updater<NoInfer<TQueryFnData> | undefined, NoInfer<TQueryFnData> | undefined>, options?: SetDataOptions): Array<[QueryKey, TQueryFnData | undefined]>;
   getQueryState<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(queryKey: TTaggedQueryKey): QueryState<TInferredQueryFnData, TInferredError> | undefined;
   removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: QueryFilters<TTaggedQueryKey>): void;
   resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: QueryFilters<TTaggedQueryKey>, options?: ResetOptions): Promise<void>;
   cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: QueryFilters<TTaggedQueryKey>, cancelOptions?: CancelOptions): Promise<void>;
   invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: InvalidateQueryFilters<TTaggedQueryKey>, options?: InvalidateOptions): Promise<void>;
   refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: RefetchQueryFilters<TTaggedQueryKey>, options?: RefetchOptions): Promise<void>;
+  query<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>): Promise<TData>;
+  /**
+   * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.
+   */
   fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
+  /**
+   * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
+   */
   prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+  infiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<Array<TData> extends Array<InfiniteData<TQueryFnData>> ? InfiniteData<TQueryFnData, TPageParam> : TData>;
+  /**
+   * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.
+   */
   fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
+  /**
+   * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
+   */
   prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
+  /**
+   * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
+   */
   ensureInfiniteQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: EnsureInfiniteQueryDataOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
   resumePausedMutations(): Promise<unknown>;
   getQueryCache(): QueryCache;
@@ -850,102 +649,295 @@ declare class QueryClient {
   defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
   clear(): void;
 }
-declare interface QueryClientConfig {
-  queryCache?: QueryCache;
-  mutationCache?: MutationCache;
-  defaultOptions?: DefaultOptions;
-}
-declare interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
+type ShouldRetryFunction<TError = DefaultError> = (failureCount: number, error: TError) => boolean;
+type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
+type RetryDelayFunction<TError = DefaultError> = (failureCount: number, error: TError) => number;
+type OmitKeyof<TObject, TKey extends TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject, TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
+interface Register {}
+type DefaultError = Register extends {
+  defaultError: infer TError;
+} ? TError : Error;
+type QueryKey = Register extends {
+  queryKey: infer TQueryKey;
+} ? TQueryKey extends ReadonlyArray<unknown> ? TQueryKey : TQueryKey extends Array<unknown> ? TQueryKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+declare const dataTagSymbol: unique symbol;
+type dataTagSymbol = typeof dataTagSymbol;
+declare const dataTagErrorSymbol: unique symbol;
+type dataTagErrorSymbol = typeof dataTagErrorSymbol;
+declare const unsetMarker: unique symbol;
+type UnsetMarker = typeof unsetMarker;
+type AnyDataTag = {
+  [dataTagSymbol]: any;
+  [dataTagErrorSymbol]: any;
+};
+type DataTag<TType, TValue, TError = UnsetMarker> = TType extends AnyDataTag ? TType : TType & {
+  [dataTagSymbol]: TValue;
+  [dataTagErrorSymbol]: TError;
+};
+type QueryKeyWithDataTag<TQueryKey extends QueryKey = QueryKey, TQueryFnData = unknown, TError = DefaultError> = {
+  queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown> ? TaggedValue : TQueryFnData;
+type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError> ? TaggedError extends UnsetMarker ? TError : TaggedError : TError;
+type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>;
+type StaleTime = number | 'static';
+type StaleTimeFunction<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = StaleTime | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => StaleTime);
+type QueryBooleanOption<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = boolean | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean);
+type QueryPersister<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? (queryFn: QueryFunction<T, TQueryKey, never>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T> : (queryFn: QueryFunction<T, TQueryKey, TPageParam>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T>;
+type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
   client: QueryClient;
   queryKey: TQueryKey;
-  queryHash: string;
-  options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
-  defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
-  state?: QueryState<TData, TError>;
+  signal: AbortSignal;
+  meta: QueryMeta | undefined;
+  pageParam?: unknown;
+  /**
+   * @deprecated
+   * if you want access to the direction, you can add it to the pageParam
+   */
+  direction?: unknown;
+} : {
+  client: QueryClient;
+  queryKey: TQueryKey;
+  signal: AbortSignal;
+  pageParam: TPageParam;
+  /**
+   * @deprecated
+   * if you want access to the direction, you can add it to the pageParam
+   */
+  direction: FetchDirection;
+  meta: QueryMeta | undefined;
+};
+type InitialDataFunction<T> = () => T | undefined;
+type NonFunctionGuard<T> = T extends Function ? never : T;
+type PlaceholderDataFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (previousData: TQueryData | undefined, previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => TQueryData | undefined;
+type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
+type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: Array<TQueryFnData>, lastPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
+interface InfiniteData<TData, TPageParam = unknown> {
+  pages: Array<TData>;
+  pageParams: Array<TPageParam>;
 }
-declare interface QueryFilters<TQueryKey extends QueryKey = QueryKey> {
+type QueryMeta = Register extends {
+  queryMeta: infer TQueryMeta;
+} ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
+type NetworkMode = 'online' | 'always' | 'offlineFirst';
+type NotifyOnChangeProps = Array<keyof InfiniteQueryObserverResult> | 'all' | undefined | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined);
+interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
   /**
-   * Filter to active queries, inactive queries or all queries
+   * If `false`, failed queries will not retry by default.
+   * If `true`, failed queries will retry infinitely.
+   * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
+   * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
    */
-  type?: QueryTypeFilter;
+  retry?: RetryValue<TError>;
+  retryDelay?: RetryDelayValue<TError>;
+  networkMode?: NetworkMode;
   /**
-   * Match query key exactly
+   * The time in milliseconds that unused/inactive cache data remains in memory.
+   * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
+   * When different garbage collection times are specified, the longest one will be used.
+   * Setting it to `Infinity` will disable garbage collection.
    */
-  exact?: boolean;
+  gcTime?: number;
+  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken;
+  persister?: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
+  queryHash?: string;
+  queryKey?: TQueryKey;
+  queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;
+  initialData?: TData | InitialDataFunction<TData>;
+  initialDataUpdatedAt?: number | (() => number | undefined);
+  behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>;
   /**
-   * Include queries matching this predicate function
+   * Set this to `false` to disable structural sharing between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
+   * Defaults to `true`.
    */
-  predicate?: (query: Query) => boolean;
+  structuralSharing?: boolean | ((oldData: unknown | undefined, newData: unknown) => unknown);
+  _defaulted?: boolean;
+  _type?: 'infinite';
   /**
-   * Include queries matching this query key
+   * Additional payload to be stored on each query.
+   * Use this property to pass information that can be used in other places.
    */
-  queryKey?: TQueryKey | TuplePrefixes<TQueryKey>;
+  meta?: QueryMeta;
   /**
-   * Include or exclude stale queries
+   * Maximum number of pages to store in the data of an infinite query.
    */
-  stale?: boolean;
+  maxPages?: number;
+}
+interface InitialPageParam<TPageParam = unknown> {
+  initialPageParam: TPageParam;
+}
+type ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
   /**
-   * Include queries matching their fetchStatus
+   * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.
+   * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
+   * Accepts a boolean or function that returns a boolean.
+   * Defaults to `true`.
    */
-  fetchStatus?: FetchStatus;
+  enabled?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * The time in milliseconds after data is considered stale.
+   * If set to `Infinity`, the data will never be considered stale.
+   * If set to a function, the function will be executed with the query to compute a `staleTime`.
+   * Defaults to `0`.
+   */
+  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * If set to a number, the query will continuously refetch at this frequency in milliseconds.
+   * If set to a function, the function will be executed with the latest data and query to compute a frequency
+   * Defaults to `false`.
+   */
+  refetchInterval?: number | false | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => number | false | undefined);
+  /**
+   * If set to `true`, the query will continue to refetch while their tab/window is in the background.
+   * Defaults to `false`.
+   */
+  refetchIntervalInBackground?: boolean;
+  /**
+   * If set to `true`, the query will refetch on window focus if the data is stale.
+   * If set to `false`, the query will not refetch on window focus.
+   * If set to `'always'`, the query will always refetch on window focus.
+   * If set to a function, the function will be executed with the latest data and query to compute the value.
+   * Defaults to `true`.
+   */
+  refetchOnWindowFocus?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  /**
+   * If set to `true`, the query will refetch on reconnect if the data is stale.
+   * If set to `false`, the query will not refetch on reconnect.
+   * If set to `'always'`, the query will always refetch on reconnect.
+   * If set to a function, the function will be executed with the latest data and query to compute the value.
+   * Defaults to `true` unless `networkMode` is `'always'`.
+   */
+  refetchOnReconnect?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  /**
+   * If set to `true`, the query will refetch on mount if the data is stale.
+   * If set to `false`, will disable additional instances of a query to trigger background refetch.
+   * If set to `'always'`, the query will always refetch on mount.
+   * If set to a function, the function will be executed with the latest data and query to compute the value
+   * Defaults to `true`.
+   */
+  refetchOnMount?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  /**
+   * If set to `false`, the query will not be retried on mount if it contains an error.
+   * If set to a function, the function will be executed with the query to compute the value.
+   * Defaults to `true`.
+   */
+  retryOnMount?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * If set, the component will only re-render if any of the listed properties change.
+   * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
+   * When set to `'all'`, the component will re-render whenever a query is updated.
+   * When set to a function, the function will be executed to compute the list of properties.
+   * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.
+   */
+  notifyOnChangeProps?: NotifyOnChangeProps;
+  /**
+   * Whether errors should be thrown instead of setting the `error` property.
+   * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
+   * If set to `false` and `suspense` is `false`, errors are returned as state.
+   * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
+   * Defaults to `false`.
+   */
+  throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * This option can be used to transform or select a part of the data returned by the query function.
+   */
+  select?: (data: TQueryData) => TData;
+  /**
+   * If set to `true`, the query will suspend when `status === 'pending'`
+   * and throw errors when `status === 'error'`.
+   * Defaults to `false`.
+   */
+  suspense?: boolean;
+  /**
+   * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.
+   */
+  placeholderData?: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
+  _optimisticResults?: 'optimistic' | 'isRestoring';
 }
-declare type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>;
-declare type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
-  client: QueryClient;
-  queryKey: TQueryKey;
-  signal: AbortSignal;
-  meta: QueryMeta | undefined;
-  pageParam?: unknown;
+type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & { [_ in TKey]: {}; };
+type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwOnError' | 'refetchOnReconnect' | 'queryHash'>;
+interface QueryExecuteOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
+  initialPageParam?: never;
+  select?: (data: TQueryData) => TData;
+  /**
+   * The time in milliseconds after data is considered stale.
+   * If the data is fresh it will be returned from the cache.
+   */
+  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
+}
+/** @deprecated */
+interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'> {
+  initialPageParam?: never;
+  /**
+   * The time in milliseconds after data is considered stale.
+   * If the data is fresh it will be returned from the cache.
+   */
+  staleTime?: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>;
+}
+/** @deprecated */
+interface EnsureQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> {
+  revalidateIfStale?: boolean;
+}
+/** @deprecated */
+type EnsureInfiniteQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+  revalidateIfStale?: boolean;
+};
+type InfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> = {
+  pages?: never;
+} | {
+  pages: number;
+  getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
+};
+type InfiniteQueryExecuteOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Omit<QueryExecuteOptions<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey, TPageParam>, 'initialPageParam'> & InitialPageParam<TPageParam> & InfiniteQueryPages<TQueryFnData, TPageParam>;
+/** @deprecated */
+type FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Omit<FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData, TPageParam>, TQueryKey, TPageParam>, 'initialPageParam'> & InitialPageParam<TPageParam> & InfiniteQueryPages<TQueryFnData, TPageParam>;
+interface ResultOptions {
+  throwOnError?: boolean;
+}
+interface RefetchOptions extends ResultOptions {
+  /**
+   * If set to `true`, a currently running request will be cancelled before a new request is made
+   *
+   * If set to `false`, no refetch will be made if there is already a request running.
+   *
+   * Defaults to `true`.
+   */
+  cancelRefetch?: boolean;
+}
+interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {
+  refetchType?: QueryTypeFilter | 'none';
+}
+interface RefetchQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {}
+interface InvalidateOptions extends RefetchOptions {}
+interface ResetOptions extends RefetchOptions {}
+interface FetchNextPageOptions extends ResultOptions {
   /**
-   * @deprecated
-   * if you want access to the direction, you can add it to the pageParam
+   * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,
+   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
+   *
+   * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.
+   *
+   * Defaults to `true`.
    */
-  direction?: unknown;
-} : {
-  client: QueryClient;
-  queryKey: TQueryKey;
-  signal: AbortSignal;
-  pageParam: TPageParam;
+  cancelRefetch?: boolean;
+}
+interface FetchPreviousPageOptions extends ResultOptions {
   /**
-   * @deprecated
-   * if you want access to the direction, you can add it to the pageParam
+   * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,
+   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
+   *
+   * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.
+   *
+   * Defaults to `true`.
    */
-  direction: FetchDirection;
-  meta: QueryMeta | undefined;
-};
-declare type QueryKey = Register extends {
-  queryKey: infer TQueryKey;
-} ? TQueryKey extends ReadonlyArray<unknown> ? TQueryKey : TQueryKey extends Array<unknown> ? TQueryKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
-declare type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
-declare type QueryMeta = Register extends {
-  queryMeta: infer TQueryMeta;
-} ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
-declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Subscribable<QueryObserverListener<TData, TError>> {
-  #private;
-  options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
-  constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
-  protected bindMethods(): void;
-  protected onSubscribe(): void;
-  protected onUnsubscribe(): void;
-  shouldFetchOnReconnect(): boolean;
-  shouldFetchOnWindowFocus(): boolean;
-  destroy(): void;
-  setOptions(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): void;
-  getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
-  getCurrentResult(): QueryObserverResult<TData, TError>;
-  trackResult(result: QueryObserverResult<TData, TError>, onPropTracked?: (key: keyof QueryObserverResult) => void): QueryObserverResult<TData, TError>;
-  trackProp(key: keyof QueryObserverResult): void;
-  getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
-  refetch({
-    ...options
-  }?: RefetchOptions): Promise<QueryObserverResult<TData, TError>>;
-  fetchOptimistic(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
-  protected fetch(fetchOptions: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
-  protected createResult(query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
-  updateResult(): void;
-  onQueryUpdate(): void;
+  cancelRefetch?: boolean;
 }
-declare interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
+type QueryStatus = 'pending' | 'error' | 'success';
+type FetchStatus = 'fetching' | 'paused' | 'idle';
+interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
   /**
    * The last successfully resolved data for the query.
    */
@@ -1066,58 +1058,31 @@ declare interface QueryObserverBaseResult<TData = unknown, TError = DefaultError
    * - See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
    */
   fetchStatus: FetchStatus;
-  /**
-   * A stable promise that will be resolved with the data of the query.
-   * Requires the `experimental_prefetchInRender` feature flag to be enabled.
-   * @example
-   *
-   * ### Enabling the feature flag
-   * ```ts
-   * const client = new QueryClient({
-   *   defaultOptions: {
-   *     queries: {
-   *       experimental_prefetchInRender: true,
-   *     },
-   *   },
-   * })
-   * ```
-   *
-   * ### Usage
-   * ```tsx
-   * import { useQuery } from '@tanstack/react-query'
-   * import React from 'react'
-   * import { fetchTodos, type Todo } from './api'
-   *
-   * function TodoList({ query }: { query: UseQueryResult<Todo[], Error> }) {
-   *   const data = React.use(query.promise)
-   *
-   *   return (
-   *     <ul>
-   *       {data.map(todo => (
-   *         <li key={todo.id}>{todo.title}</li>
-   *       ))}
-   *     </ul>
-   *   )
-   * }
-   *
-   * export function App() {
-   *   const query = useQuery({ queryKey: ['todos'], queryFn: fetchTodos })
-   *
-   *   return (
-   *     <>
-   *       <h1>Todos</h1>
-   *       <React.Suspense fallback={<div>Loading...</div>}>
-   *         <TodoList query={query} />
-   *       </React.Suspense>
-   *     </>
-   *   )
-   * }
-   * ```
-   */
-  promise: Promise<TData>;
-}
-declare type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
-declare interface QueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+}
+interface QueryObserverPendingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+interface QueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+interface QueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
   data: undefined;
   error: TError;
   isError: true;
@@ -1129,329 +1094,361 @@ declare interface QueryObserverLoadingErrorResult<TData = unknown, TError = Defa
   isPlaceholderData: false;
   status: 'error';
 }
-declare interface QueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
-  data: undefined;
+interface QueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+interface QueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
   error: null;
   isError: false;
-  isPending: true;
-  isLoading: true;
+  isPending: false;
+  isLoading: false;
   isLoadingError: false;
   isRefetchError: false;
-  isSuccess: false;
+  isSuccess: true;
   isPlaceholderData: false;
-  status: 'pending';
+  status: 'success';
+}
+interface QueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: 'success';
 }
-declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
+type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
+type QueryObserverResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError> | QueryObserverPendingResult<TData, TError> | QueryObserverPlaceholderResult<TData, TError>;
+interface InfiniteQueryObserverBaseResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
   /**
-   * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.
-   * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
-   * Accepts a boolean or function that returns a boolean.
-   * Defaults to `true`.
+   * This function allows you to fetch the next "page" of results.
    */
-  enabled?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
+  fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
   /**
-   * The time in milliseconds after data is considered stale.
-   * If set to `Infinity`, the data will never be considered stale.
-   * If set to a function, the function will be executed with the query to compute a `staleTime`.
-   * Defaults to `0`.
+   * This function allows you to fetch the previous "page" of results.
    */
-  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
+  fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
   /**
-   * If set to a number, the query will continuously refetch at this frequency in milliseconds.
-   * If set to a function, the function will be executed with the latest data and query to compute a frequency
-   * Defaults to `false`.
+   * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
    */
-  refetchInterval?: number | false | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => number | false | undefined);
+  hasNextPage: boolean;
   /**
-   * If set to `true`, the query will continue to refetch while their tab/window is in the background.
-   * Defaults to `false`.
+   * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
    */
-  refetchIntervalInBackground?: boolean;
+  hasPreviousPage: boolean;
+  /**
+   * Will be `true` if the query failed while fetching the next page.
+   */
+  isFetchNextPageError: boolean;
+  /**
+   * Will be `true` while fetching the next page with `fetchNextPage`.
+   */
+  isFetchingNextPage: boolean;
+  /**
+   * Will be `true` if the query failed while fetching the previous page.
+   */
+  isFetchPreviousPageError: boolean;
+  /**
+   * Will be `true` while fetching the previous page with `fetchPreviousPage`.
+   */
+  isFetchingPreviousPage: boolean;
+}
+interface InfiniteQueryObserverPendingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: 'success';
+}
+interface InfiniteQueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: TData;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  status: 'success';
+}
+type DefinedInfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
+type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError> | InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverPendingResult<TData, TError> | InfiniteQueryObserverPlaceholderResult<TData, TError>;
+type MutationKey = Register extends {
+  mutationKey: infer TMutationKey;
+} ? TMutationKey extends ReadonlyArray<unknown> ? TMutationKey : TMutationKey extends Array<unknown> ? TMutationKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+type MutationScope = {
+  id: string;
+};
+type MutationMeta = Register extends {
+  mutationMeta: infer TMutationMeta;
+} ? TMutationMeta extends Record<string, unknown> ? TMutationMeta : Record<string, unknown> : Record<string, unknown>;
+type MutationFunctionContext = {
+  client: QueryClient;
+  meta: MutationMeta | undefined;
+  mutationKey?: MutationKey;
+};
+type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables, context: MutationFunctionContext) => Promise<TData>;
+interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
+  mutationFn?: MutationFunction<TData, TVariables>;
+  mutationKey?: MutationKey;
+  onMutate?: (variables: TVariables, context: MutationFunctionContext) => Promise<TOnMutateResult> | TOnMutateResult;
+  onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  retry?: RetryValue<TError>;
+  retryDelay?: RetryDelayValue<TError>;
+  networkMode?: NetworkMode;
+  gcTime?: number;
+  _defaulted?: boolean;
+  meta?: MutationMeta;
+  scope?: MutationScope;
+}
+interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {
+  throwOnError?: boolean | ((error: TError) => boolean);
+}
+interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
+  onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+  onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+}
+type MutateFunctionRest<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = undefined extends TVariables ? [variables?: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>] : [variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>];
+type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...rest: MutateFunctionRest<TData, TError, TVariables, TOnMutateResult>) => Promise<TData>;
+interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationState<TData, TError, TVariables, TOnMutateResult> {
   /**
-   * If set to `true`, the query will refetch on window focus if the data is stale.
-   * If set to `false`, the query will not refetch on window focus.
-   * If set to `'always'`, the query will always refetch on window focus.
-   * If set to a function, the function will be executed with the latest data and query to compute the value.
-   * Defaults to `true`.
+   * The last successfully resolved data for the mutation.
    */
-  refetchOnWindowFocus?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  data: TData | undefined;
   /**
-   * If set to `true`, the query will refetch on reconnect if the data is stale.
-   * If set to `false`, the query will not refetch on reconnect.
-   * If set to `'always'`, the query will always refetch on reconnect.
-   * If set to a function, the function will be executed with the latest data and query to compute the value.
-   * Defaults to the value of `networkOnline` (`true`)
+   * The variables object passed to the `mutationFn`.
    */
-  refetchOnReconnect?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  variables: TVariables | undefined;
   /**
-   * If set to `true`, the query will refetch on mount if the data is stale.
-   * If set to `false`, will disable additional instances of a query to trigger background refetch.
-   * If set to `'always'`, the query will always refetch on mount.
-   * If set to a function, the function will be executed with the latest data and query to compute the value
-   * Defaults to `true`.
+   * The error object for the mutation, if an error was encountered.
+   * - Defaults to `null`.
    */
-  refetchOnMount?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  error: TError | null;
   /**
-   * If set to `false`, the query will not be retried on mount if it contains an error.
-   * If set to a function, the function will be executed with the query to compute the value.
-   * Defaults to `true`.
+   * A boolean variable derived from `status`.
+   * - `true` if the last mutation attempt resulted in an error.
    */
-  retryOnMount?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
+  isError: boolean;
   /**
-   * If set, the component will only re-render if any of the listed properties change.
-   * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
-   * When set to `'all'`, the component will re-render whenever a query is updated.
-   * When set to a function, the function will be executed to compute the list of properties.
-   * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.
+   * A boolean variable derived from `status`.
+   * - `true` if the mutation is in its initial state prior to executing.
    */
-  notifyOnChangeProps?: NotifyOnChangeProps;
+  isIdle: boolean;
   /**
-   * Whether errors should be thrown instead of setting the `error` property.
-   * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
-   * If set to `false` and `suspense` is `false`, errors are returned as state.
-   * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
-   * Defaults to `false`.
+   * A boolean variable derived from `status`.
+   * - `true` if the mutation is currently executing.
    */
-  throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
+  isPending: boolean;
   /**
-   * This option can be used to transform or select a part of the data returned by the query function.
+   * A boolean variable derived from `status`.
+   * - `true` if the last mutation attempt was successful.
    */
-  select?: (data: TQueryData) => TData;
+  isSuccess: boolean;
   /**
-   * If set to `true`, the query will suspend when `status === 'pending'`
-   * and throw errors when `status === 'error'`.
-   * Defaults to `false`.
+   * The status of the mutation.
+   * - Will be:
+   *   - `idle` initial status prior to the mutation function executing.
+   *   - `pending` if the mutation is currently executing.
+   *   - `error` if the last mutation attempt resulted in an error.
+   *   - `success` if the last mutation attempt was successful.
    */
-  suspense?: boolean;
+  status: MutationStatus;
   /**
-   * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.
+   * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
+   * @param variables - The variables object to pass to the `mutationFn`.
+   * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.
+   * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.
+   * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
+   * @remarks
+   * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
+   * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
    */
-  placeholderData?: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
-  _optimisticResults?: 'optimistic' | 'isRestoring';
+  mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
   /**
-   * Enable prefetching during rendering
+   * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
    */
-  experimental_prefetchInRender?: boolean;
+  reset: () => void;
 }
-declare interface QueryObserverPendingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
   data: undefined;
+  variables: undefined;
   error: null;
   isError: false;
-  isPending: true;
-  isLoadingError: false;
-  isRefetchError: false;
+  isIdle: true;
+  isPending: false;
   isSuccess: false;
-  isPlaceholderData: false;
-  status: 'pending';
+  status: 'idle';
 }
-declare interface QueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
-  data: TData;
-  isError: false;
+interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
+  data: undefined;
+  variables: TVariables;
   error: null;
-  isPending: false;
-  isLoading: false;
-  isLoadingError: false;
-  isRefetchError: false;
-  isSuccess: true;
-  isPlaceholderData: true;
-  status: 'success';
+  isError: false;
+  isIdle: false;
+  isPending: true;
+  isSuccess: false;
+  status: 'pending';
 }
-declare interface QueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
-  data: TData;
+interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
+  data: undefined;
   error: TError;
+  variables: TVariables;
   isError: true;
+  isIdle: false;
   isPending: false;
-  isLoading: false;
-  isLoadingError: false;
-  isRefetchError: true;
   isSuccess: false;
-  isPlaceholderData: false;
   status: 'error';
 }
-declare type QueryObserverResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError> | QueryObserverPendingResult<TData, TError> | QueryObserverPlaceholderResult<TData, TError>;
-declare interface QueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
   data: TData;
   error: null;
+  variables: TVariables;
   isError: false;
+  isIdle: false;
   isPending: false;
-  isLoading: false;
-  isLoadingError: false;
-  isRefetchError: false;
   isSuccess: true;
-  isPlaceholderData: false;
   status: 'success';
 }
-declare interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
-  /**
-   * If `false`, failed queries will not retry by default.
-   * If `true`, failed queries will retry infinitely., failureCount: num
-   * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
-   * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
-   */
-  retry?: RetryValue<TError>;
-  retryDelay?: RetryDelayValue<TError>;
-  networkMode?: NetworkMode;
-  /**
-   * The time in milliseconds that unused/inactive cache data remains in memory.
-   * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
-   * When different garbage collection times are specified, the longest one will be used.
-   * Setting it to `Infinity` will disable garbage collection.
-   */
-  gcTime?: number;
-  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken;
-  persister?: QueryPersister<TQueryFnData, TQueryKey, TPageParam>;
-  queryHash?: string;
-  queryKey?: TQueryKey;
-  queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;
-  initialData?: TData | InitialDataFunction<TData>;
-  initialDataUpdatedAt?: number | (() => number | undefined);
-  behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>;
-  /**
-   * Set this to `false` to disable structural sharing between query results.
-   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
-   * Defaults to `true`.
-   */
-  structuralSharing?: boolean | ((oldData: unknown | undefined, newData: unknown) => unknown);
-  _defaulted?: boolean;
-  _type?: 'infinite';
-  /**
-   * Additional payload to be stored on each query.
-   * Use this property to pass information that can be used in other places.
-   */
-  meta?: QueryMeta;
-  /**
-   * Maximum number of pages to store in the data of an infinite query.
-   */
-  maxPages?: number;
-}
-declare type QueryPersister<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? (queryFn: QueryFunction<T, TQueryKey, never>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T> : (queryFn: QueryFunction<T, TQueryKey, TPageParam>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T>;
-declare interface QueryState<TData = unknown, TError = DefaultError> {
-  data: TData | undefined;
-  dataUpdateCount: number;
-  dataUpdatedAt: number;
-  error: TError | null;
-  errorUpdateCount: number;
-  errorUpdatedAt: number;
-  fetchFailureCount: number;
-  fetchFailureReason: TError | null;
-  fetchMeta: FetchMeta | null;
-  isInvalidated: boolean;
-  status: QueryStatus;
-  fetchStatus: FetchStatus;
-}
-declare type QueryStatus = 'pending' | 'error' | 'success';
-declare type QueryTypeFilter = 'all' | 'active' | 'inactive';
-declare interface RefetchOptions extends ResultOptions {
-  /**
-   * If set to `true`, a currently running request will be cancelled before a new request is made
-   *
-   * If set to `false`, no refetch will be made if there is already a request running.
-   *
-   * Defaults to `true`.
-   */
-  cancelRefetch?: boolean;
+type MutationObserverResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverLoadingResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverErrorResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverSuccessResult<TData, TError, TVariables, TOnMutateResult>;
+interface QueryClientConfig {
+  queryCache?: QueryCache;
+  mutationCache?: MutationCache;
+  defaultOptions?: DefaultOptions;
 }
-declare interface RefetchQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {}
-declare interface Register {}
-declare abstract class Removable {
-  #private;
-  gcTime: number;
-  destroy(): void;
-  protected scheduleGc(): void;
-  protected updateGcTime(newGcTime: number | undefined): void;
-  protected clearGcTimeout(): void;
-  protected abstract optionalRemove(): void;
+interface DefaultOptions<TError = DefaultError> {
+  queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'suspense' | 'queryKey'>;
+  mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
+  hydrate?: HydrateOptions['defaultOptions'];
+  dehydrate?: DehydrateOptions;
 }
-declare interface ResetOptions extends RefetchOptions {}
-declare interface ResultOptions {
-  throwOnError?: boolean;
+interface CancelOptions {
+  revert?: boolean;
+  silent?: boolean;
 }
-declare type RetryDelayFunction<TError = DefaultError> = (failureCount: number, error: TError) => number;
-declare type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
-declare type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
-declare interface SetDataOptions {
+interface SetDataOptions {
   updatedAt?: number;
 }
-declare interface SetStateAction<TData, TError> {
-  type: 'setState';
-  state: Partial<QueryState<TData, TError>>;
-}
-declare type ShouldRetryFunction<TError = DefaultError> = (failureCount: number, error: TError) => boolean;
-declare type SkipToken = typeof skipToken;
-declare const skipToken: unique symbol;
-declare type StaleTime = number | 'static';
-declare type StaleTimeFunction<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = StaleTime | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => StaleTime);
-declare class Subscribable<TListener extends Function> {
-  protected listeners: Set<TListener>;
-  constructor();
-  subscribe(listener: TListener): () => void;
-  hasListeners(): boolean;
-  protected onSubscribe(): void;
-  protected onUnsubscribe(): void;
+type NotifyEventType = 'added' | 'removed' | 'updated' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
+interface NotifyEvent {
+  type: NotifyEventType;
 }
-declare interface SuccessAction<TData> {
-  data: TData | undefined;
-  type: 'success';
-  dataUpdatedAt?: number;
-  manual?: boolean;
+//#endregion
+//#region src/hydration.d.ts
+type TransformerFn = (data: any) => any;
+interface DehydrateOptions {
+  serializeData?: TransformerFn;
+  shouldDehydrateMutation?: (mutation: Mutation) => boolean;
+  shouldDehydrateQuery?: (query: Query) => boolean;
+  shouldRedactErrors?: (error: unknown) => boolean;
 }
-declare interface SuccessAction_2<TData> {
-  type: 'success';
-  data: TData;
+interface HydrateOptions {
+  defaultOptions?: {
+    deserializeData?: TransformerFn;
+    queries?: QueryOptions;
+    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>;
+  };
 }
-/**
- * In many cases code wants to delay to the next event loop tick; this is not
- * mediated by {@link timeoutManager}.
- *
- * This function is provided to make auditing the `tanstack/query-core` for
- * incorrect use of system `setTimeout` easier.
- */
-declare type ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
-declare type TransformerFn = (data: any) => any;
-/**
- * This function takes a Promise-like input and detects whether the data
- * is synchronously available or not.
- *
- * It does not inspect .status, .value or .reason properties of the promise,
- * as those are not always available, and the .status of React's promises
- * should not be considered part of the public API.
- */
-declare type TuplePrefixes<T extends ReadonlyArray<unknown>> = T extends readonly [] ? readonly [] : TuplePrefixes<DropLast<T>> | T;
-declare type UnsetMarker = typeof unsetMarker;
-declare const unsetMarker: unique symbol;
-declare type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
-declare type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & { [_ in TKey]: {} };
 //#endregion
 //#region src/queries/contentQueries.d.ts
 /**
  * Query options factory for content queries
  * Use with TanStack Query's useQuery hook
  */
-declare const contentQueries: {
+export declare const contentQueries: {
   /**
    * Query options for paginated content list
    * @param params - List parameters including type, pagination, filters
    */
-  list: <C extends CustomFields = CustomFields>(params?: ContentListParams) => OmitKeyof<_$_tanstack_react_query0.UseQueryOptions<ContentResponse<C>, Error, ContentResponse<C>, readonly ["content", "list", string, ContentListParams]>, "queryFn"> & {
+  list: <C extends CustomFields = CustomFields>(params?: ContentListParams) => OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ContentResponse<C>, Error, ContentResponse<C>, readonly ["content", "list", string, ContentListParams]>, "queryFn"> & {
     queryFn?: QueryFunction<ContentResponse<C>, readonly ["content", "list", string, ContentListParams], never> | undefined;
-  } & {
-    queryKey: readonly ["content", "list", string, ContentListParams] & {
-      [dataTagSymbol]: ContentResponse<C>;
-      [dataTagErrorSymbol]: Error;
-    };
-  };
+  } & QueryKeyWithDataTag<readonly ["content", "list", string, ContentListParams], ContentResponse<C>, Error>;
   /**
    * Query options for a single content item by ID
    * @param id - Content item ID
    */
-  detail: <C extends CustomFields = CustomFields>(id: number) => OmitKeyof<_$_tanstack_react_query0.UseQueryOptions<ApiResponse<ContentDto<C>>, Error, ApiResponse<ContentDto<C>>, readonly ["content", "detail", number]>, "queryFn"> & {
+  detail: <C extends CustomFields = CustomFields>(id: number) => OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ApiResponse<ContentDto<C>>, Error, ApiResponse<ContentDto<C>>, readonly ["content", "detail", number]>, "queryFn"> & {
     queryFn?: QueryFunction<ApiResponse<ContentDto<C>>, readonly ["content", "detail", number], never> | undefined;
-  } & {
-    queryKey: readonly ["content", "detail", number] & {
-      [dataTagSymbol]: ApiResponse<ContentDto<C>>;
-      [dataTagErrorSymbol]: Error;
-    };
-  };
+  } & QueryKeyWithDataTag<readonly ["content", "detail", number], ApiResponse<ContentDto<C>>, Error>;
   /**
    * Query options for fetching all content items (across all pages)
    * @param params - List parameters (without page)
@@ -1459,7 +1456,7 @@ declare const contentQueries: {
    */
   listAll: <C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, "page"> & {
     page?: never;
-  }, options?: FetchAllOptions<C, T>) => OmitKeyof<_$_tanstack_react_query0.UseQueryOptions<T[], Error, T[], readonly ["content", "all", string, {
+  }, options?: FetchAllOptions<C, T>) => OmitKeyof<import("@tanstack/react-query").UseQueryOptions<T[], Error, T[], readonly ["content", "all", string, {
     readonly mode: "all";
     readonly size?: number;
     readonly sortBy?: string;
@@ -1475,19 +1472,14 @@ declare const contentQueries: {
       readonly type?: string;
       readonly filters?: Record<string, string | number | boolean | null | undefined>;
     }], never> | undefined;
-  } & {
-    queryKey: readonly ["content", "all", string, {
-      readonly mode: "all";
-      readonly size?: number;
-      readonly sortBy?: string;
-      readonly direction?: "ASC" | "DESC";
-      readonly type?: string;
-      readonly filters?: Record<string, string | number | boolean | null | undefined>;
-    }] & {
-      [dataTagSymbol]: T[];
-      [dataTagErrorSymbol]: Error;
-    };
-  };
+  } & QueryKeyWithDataTag<readonly ["content", "all", string, {
+    readonly mode: "all";
+    readonly size?: number;
+    readonly sortBy?: string;
+    readonly direction?: "ASC" | "DESC";
+    readonly type?: string;
+    readonly filters?: Record<string, string | number | boolean | null | undefined>;
+  }], T[], Error>;
 };
 //#endregion
 //#region src/queries/queryKeys.d.ts
@@ -1495,7 +1487,7 @@ declare const contentQueries: {
  * Hierarchical query key factory for content queries
  * Following TanStack Query best practices for key structure
  */
-declare const contentKeys: {
+export declare const contentKeys: {
   /**
    * Base key for all content queries
    */
@@ -1543,25 +1535,25 @@ declare const contentKeys: {
  * Hook for fetching paginated content list
  * @param params - List parameters including type, pagination, filters
  */
-declare function useContentList<C extends CustomFields = CustomFields>(params?: ContentListParams): UseQueryResult<ContentResponse<C>>;
+export declare function useContentList<C extends CustomFields = CustomFields>(params?: ContentListParams): UseQueryResult<ContentResponse<C>>;
 /**
  * Hook for fetching a single content item by ID
  * @param id - Content item ID
  */
-declare function useContentDetail<C extends CustomFields = CustomFields>(id: number): UseQueryResult<ApiResponse<ContentDto<C>>>;
+export declare function useContentDetail<C extends CustomFields = CustomFields>(id: number): UseQueryResult<ApiResponse<ContentDto<C>>>;
 /**
  * Hook for fetching all content items across pages
  * @param params - List parameters (without page)
  * @param options - Fetch options including mapping and deduplication
  */
-declare function useContentAll<C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, 'page'> & {
+export declare function useContentAll<C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, 'page'> & {
   page?: never;
 }, options?: FetchAllOptions<C, T>): UseQueryResult<T[]>;
 /**
  * Hook for prefetching content queries
  * Useful for optimistic navigation and hover effects
  */
-declare function useContentPrefetch(): {
+export declare function useContentPrefetch(): {
   /**
    * Prefetch a content list
    */
@@ -1589,7 +1581,7 @@ type BuildAssetUrlOpts = {
   apiBase?: string;
   fileBase?: string;
 };
-declare const buildAssetUrl: (rawPath?: string | null, opts?: BuildAssetUrlOpts) => string;
+export declare const buildAssetUrl: (rawPath?: string | null, opts?: BuildAssetUrlOpts) => string;
 //#endregion
 //#region src/utils/normalization.d.ts
 /**
@@ -1604,7 +1596,7 @@ declare const buildAssetUrl: (rawPath?: string | null, opts?: BuildAssetUrlOpts)
  * @param item - Raw content item from the API
  * @returns Normalized content item
  */
-declare function normalizeContentItem<C extends CustomFields = CustomFields>(item: ContentDto<C>): NormalizedContentItem;
+export declare function normalizeContentItem<C extends CustomFields = CustomFields>(item: ContentDto<C>): NormalizedContentItem;
 /**
  * Build an asset URL using the SDK's configured base URLs
  * This is a convenience wrapper that automatically uses SDK config
@@ -1612,7 +1604,7 @@ declare function normalizeContentItem<C extends CustomFields = CustomFields>(ite
  * @param path - Path to the asset (can be relative or absolute)
  * @returns Full URL to the asset
  */
-declare function buildAssetUrlWithConfig(path?: string | null): string;
+export declare function buildAssetUrlWithConfig(path?: string | null): string;
 //#endregion
 //#region src/utils/richText.d.ts
 /**
@@ -1630,7 +1622,7 @@ declare function buildAssetUrlWithConfig(path?: string | null): string;
  * stripHtmlTags('<p>Hello <strong>world</strong></p>') // → 'Hello world'
  * stripHtmlTags('<ul><li>A</li><li>B</li></ul>')       // → 'A B'
  */
-declare function stripHtmlTags(html: string): string;
+export declare function stripHtmlTags(html: string): string;
 /**
  * Returns `true` if the given string contains HTML markup.
  *
@@ -1647,10 +1639,10 @@ declare function stripHtmlTags(html: string): string;
  * isHtmlContent('Just text')              // → false
  * isHtmlContent('if x < 10 then')        // → false
  */
-declare function isHtmlContent(value: string): boolean;
+export declare function isHtmlContent(value: string): boolean;
 //#endregion
 //#region src/errors/CmsError.d.ts
-declare class CmsError extends Error {
+export declare class CmsError extends Error {
   readonly status?: number;
   readonly data?: unknown;
   constructor(message: string, opts?: {
@@ -1664,19 +1656,18 @@ declare class CmsError extends Error {
 /**
  * Get the current SDK configuration
  */
-declare function getConfig(): SdkConfig;
+export declare function getConfig(): SdkConfig;
 /**
  * Set the SDK configuration
  */
-declare function setConfig(config: SdkConfig): void;
+export declare function setConfig(config: SdkConfig): void;
 /**
  * Check if SDK is initialized
  */
-declare function isInitialized(): boolean;
+export declare function isInitialized(): boolean;
 /**
  * Reset configuration (useful for testing)
  */
-declare function resetConfig(): void;
+export declare function resetConfig(): void;
 //#endregion
-export { ApiResponse, CmsError, ContentDto, ContentListParams, ContentResponse, CustomFields, FetchAllOptions, JsonPrimitive, JsonValue, NormalizedContentItem, PaginatedData, SdkConfig, apiClient, buildAssetUrl, buildAssetUrlWithConfig, contentKeys, contentQueries, createApiClient, downloadFile, fetchAllContent, fetchContentById, fetchContentByType, getApiClient, getConfig, isHtmlContent, isInitialized, normalizeContentItem, resetApiClient, resetConfig, setConfig, stripHtmlTags, useContentAll, useContentDetail, useContentList, useContentPrefetch };
 //# sourceMappingURL=index.d.cts.map