reactjrx 1.80.1 → 1.82.0

package/dist/lib/binding/types.d.ts

@@ -1,2 +1,3 @@
-import { type Observable } from "rxjs";
+import { Observable } from 'rxjs';
+
 export type SubscribeSource<Data> = (() => Observable<Data>) | Promise<Data> | Observable<Data> | (() => Promise<Data>) | (() => Data) | Data;

package/dist/lib/binding/useBehaviorSubject.d.ts

@@ -1,4 +1,5 @@
-import { BehaviorSubject } from "rxjs";
+import { BehaviorSubject } from 'rxjs';
+
 /**
  * @important
  * Because of React 18 and its strict mode

package/dist/lib/binding/useLiveBehaviorSubject.d.ts

@@ -0,0 +1,3 @@
+export declare const useLiveBehaviorSubject: <S>(state: S) => {
+    current: import('rxjs').BehaviorSubject<S>;
+};

package/dist/lib/binding/useObservableEvent.d.ts

@@ -1,4 +1,4 @@
 /**
  * This creates an event handler and an observable that represents calls to that handler.
  */
-export declare const useObserveCallback: <T = void>() => readonly [import("rxjs").Observable<T>, (arg: T) => void];
+export declare const useObserveCallback: <T = void>() => readonly [import('rxjs').Observable<T>, (arg: T) => void];

package/dist/lib/binding/useObservableState.d.ts

@@ -1,4 +1,5 @@
-import { type Observable } from "rxjs";
+import { Observable } from 'rxjs';
+
 /**
  * If you need to represent some piece of state as an observable and also want the ability to change
  * this state during the lifetime of the component, useObservableState

package/dist/lib/binding/useObserve.d.ts

@@ -1,13 +1,10 @@
-import { type DependencyList } from "react";
-import { type Observable, type BehaviorSubject } from "rxjs";
+import { Observable, BehaviorSubject } from 'rxjs';
+import { DependencyList } from 'react';
+
 interface Option<R = undefined> {
     defaultValue: R;
-    key?: string;
     unsubscribeOnUnmount?: boolean;
 }
-/**
- * @todo return first value if source is behavior subject
- */
 export declare function useObserve<T>(source: BehaviorSubject<T>): T;
 export declare function useObserve<T>(source: Observable<T>): T | undefined;
 export declare function useObserve<T>(source: () => Observable<T>, deps: DependencyList): T | undefined;

package/dist/lib/binding/useSubject.d.ts

@@ -1,11 +1,12 @@
-import { Subject } from "rxjs";
+import { Subject } from 'rxjs';
+
 /**
  * @see
  * useBehaviorSubject
  */
 export declare const useSubject: <S>({ onBeforeComplete, completeOnUnmount }?: {
-    onBeforeComplete?: (() => void) | undefined;
-    completeOnUnmount?: boolean | undefined;
+    onBeforeComplete?: () => void;
+    completeOnUnmount?: boolean;
 }) => {
     current: Subject<S>;
 };

package/dist/lib/binding/useSubscribe.d.ts

@@ -1,3 +1,4 @@
-import { type DependencyList } from "react";
-import { type SubscribeSource } from "./types";
+import { SubscribeSource } from './types';
+import { DependencyList } from 'react';
+
 export declare function useSubscribe<T>(source: SubscribeSource<T>, deps?: DependencyList): void;

package/dist/lib/binding/useSubscribeEffect.d.ts

@@ -1,5 +1,6 @@
-import { type DependencyList } from "react";
-import { type SubscribeSource } from "./types";
+import { SubscribeSource } from './types';
+import { DependencyList } from 'react';
+
 interface Option {
     retry?: boolean;
     onError?: (error: unknown) => void;

package/dist/lib/queries/client/QueryClient.d.ts

@@ -1,15 +1,16 @@
-import { type MutationKey } from "./mutations/types";
-import { MutationCache } from "./mutations/cache/MutationCache";
-import { type MutationObserverOptions } from "./mutations/observers/types";
-import { type MutationOptions } from "./mutations/mutation/types";
-import { QueryCache } from "./queries/cache/QueryCache";
-import { type DataTag, type Updater, type FetchQueryOptions, type QueryFilters, type SetDataOptions, type RefetchOptions } from "./queries/types";
-import { type RefetchQueryFilters, type DefaultError, type InvalidateOptions, type InvalidateQueryFilters, type ResetOptions } from "./types";
-import { type QueryKey } from "./keys/types";
-import { type DefaultedQueryObserverOptions, type QueryObserverOptions } from "./queries/observer/types";
-import { type NoInfer } from "../../utils/types";
-import { type QueryState } from "./queries/query/types";
-import { type CancelOptions } from "./queries/retryer/types";
+import { CancelOptions } from './queries/retryer/types';
+import { QueryState } from './queries/query/types';
+import { NoInfer } from '../../utils/types';
+import { DefaultedQueryObserverOptions, QueryObserverOptions } from './queries/observer/types';
+import { QueryKey } from './keys/types';
+import { RefetchQueryFilters, DefaultError, InvalidateOptions, InvalidateQueryFilters, ResetOptions } from './types';
+import { DataTag, Updater, FetchQueryOptions, QueryFilters, SetDataOptions, RefetchOptions } from './queries/types';
+import { QueryCache } from './queries/cache/QueryCache';
+import { MutationOptions } from './mutations/mutation/types';
+import { MutationObserverOptions } from './mutations/observers/types';
+import { MutationCache } from './mutations/cache/MutationCache';
+import { MutationKey } from './mutations/types';
+
 export interface DefaultOptions<TError = DefaultError> {
     queries?: Omit<QueryObserverOptions<unknown, TError>, "suspense">;
     mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
@@ -42,7 +43,7 @@ export declare class QueryClient {
     removeQueries(filters?: QueryFilters): void;
     cancelQueries(filters?: QueryFilters, cancelOptions?: CancelOptions): Promise<void>;
     invalidateQueries(filters?: InvalidateQueryFilters, options?: InvalidateOptions): Promise<void>;
-    resumePausedMutations(): Promise<import("./mutations/mutation/types").MutationState<any, any, any, any>[]>;
+    resumePausedMutations(): Promise<import('./mutations/mutation/types').MutationState<any, any, any, any>[]>;
     isFetching(filters?: QueryFilters): number;
     clear(): void;
 }

package/dist/lib/queries/client/focusManager.d.ts

@@ -1,8 +1,9 @@
-import { BehaviorSubject } from "rxjs";
+import { BehaviorSubject } from 'rxjs';
+
 export declare class FocusManager {
     #private;
     readonly focused$: BehaviorSubject<boolean>;
-    readonly focusRegained$: import("rxjs").Observable<boolean>;
+    readonly focusRegained$: import('rxjs').Observable<boolean>;
     constructor();
     isFocused(): boolean;
     setFocused(focused?: boolean): void;

package/dist/lib/queries/client/keys/hashKey.d.ts

@@ -1,3 +1,4 @@
-import { type MutationKey } from "../mutations/types";
-import { type QueryKey } from "./types";
+import { QueryKey } from './types';
+import { MutationKey } from '../mutations/types';
+
 export declare const hashKey: (queryKey: QueryKey | MutationKey) => string;

package/dist/lib/queries/client/keys/matchKey.d.ts

@@ -1,4 +1,5 @@
-import { type QueryKey } from "./types";
+import { QueryKey } from './types';
+
 export declare const matchKey: (keyA: QueryKey, keyB: QueryKey, { exact }?: {
-    exact?: boolean | undefined;
+    exact?: boolean;
 }) => boolean;

package/dist/lib/queries/client/keys/partialMatchKey.d.ts

@@ -1,4 +1,5 @@
-import { type QueryKey } from "./types";
+import { QueryKey } from './types';
+
 /**
  * Checks if key `b` partially matches with key `a`.
  */

package/dist/lib/queries/client/mutations/cache/MutationCache.d.ts

@@ -1,9 +1,10 @@
-import { Mutation } from "../mutation/Mutation";
-import { type QueryClient } from "../../QueryClient";
-import { type MutationFilters } from "../types";
-import { type MutationCacheConfig, type MutationCacheNotifyEvent } from "./types";
-import { type MutationOptions, type MutationState } from "../mutation/types";
-import { type DefaultError } from "../../types";
+import { DefaultError } from '../../types';
+import { MutationOptions, MutationState } from '../mutation/types';
+import { MutationCacheConfig, MutationCacheNotifyEvent } from './types';
+import { MutationFilters } from '../types';
+import { QueryClient } from '../../QueryClient';
+import { Mutation } from '../mutation/Mutation';
+
 export declare class MutationCache {
     #private;
     config: MutationCacheConfig;
@@ -13,12 +14,12 @@ export declare class MutationCache {
     remove(mutationToRemove: Mutation<any, any, any, any>): void;
     find<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown>(filters: MutationFilters<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext> | undefined;
     findAll<TData = unknown, TError = Error, TVariables = any, TContext = unknown>(filters?: MutationFilters<TData, TError, TVariables, TContext>): Array<Mutation<any, any, any, any>>;
-    observe(): import("rxjs").Observable<Mutation<any, any, any, any>>;
+    observe(): import('rxjs').Observable<Mutation<any, any, any, any>>;
     /**
      * @important
      * ISO api react-query
      */
     subscribe(listener: (event: MutationCacheNotifyEvent) => void): () => void;
-    resumePausedMutations(): import("rxjs").Observable<MutationState<any, any, any, any>[]>;
+    resumePausedMutations(): import('rxjs').Observable<MutationState<any, any, any, any>[]>;
     clear(): void;
 }

package/dist/lib/queries/client/mutations/cache/types.d.ts

@@ -1,6 +1,7 @@
-import { type DefaultError } from "../../types";
-import { type Mutation } from "../mutation/Mutation";
-import { type MutationObserver } from "../observers/MutationObserver";
+import { MutationObserver } from '../observers/MutationObserver';
+import { Mutation } from '../mutation/Mutation';
+import { DefaultError } from '../../types';
+
 export interface MutationCacheConfig {
     onError?: <Data = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(error: DefaultError, variables: unknown, context: unknown, mutation: Mutation<Data, TError, TVariables, TContext>) => Promise<unknown> | unknown;
     onSuccess?: (data: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;

package/dist/lib/queries/client/mutations/defaultMutationState.d.ts

@@ -1,2 +1,3 @@
-import { type MutationState } from "./mutation/types";
+import { MutationState } from './mutation/types';
+
 export declare const getDefaultMutationState: <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>() => MutationState<TData, TError, TVariables, TContext>;

package/dist/lib/queries/client/mutations/filters.d.ts

@@ -1,2 +1,3 @@
-import { type MutationFilters } from "./types";
-export declare const createPredicateForFilters: <TData = unknown, TError = Error, TVariables = any, TContext = unknown>({ mutationKey, status, predicate, exact }?: MutationFilters<TData, TError, TVariables, TContext>) => (mutation: import("./mutation/Mutation").Mutation<TData, TError, TVariables, TContext>) => boolean;
+import { MutationFilters } from './types';
+
+export declare const createPredicateForFilters: <TData = unknown, TError = Error, TVariables = any, TContext = unknown>({ mutationKey, status, predicate, exact }?: MutationFilters<TData, TError, TVariables, TContext>) => (mutation: import('./mutation/Mutation').Mutation<TData, TError, TVariables, TContext>) => boolean;

package/dist/lib/queries/client/mutations/mutation/Mutation.d.ts

@@ -1,7 +1,8 @@
-import { type Observable } from "rxjs";
-import { type DefaultError } from "../../types";
-import { type MutationCache } from "../cache/MutationCache";
-import { type MutationState, type MutationMeta, type MutationOptions } from "./types";
+import { MutationState, MutationMeta, MutationOptions } from './types';
+import { MutationCache } from '../cache/MutationCache';
+import { DefaultError } from '../../types';
+import { Observable } from 'rxjs';
+
 interface MutationConfig<TData, TError, TVariables, TContext> {
     mutationCache: MutationCache;
     options: MutationOptions<TData, TError, TVariables, TContext>;

package/dist/lib/queries/client/mutations/mutation/delayWhenNetworkOnline.d.ts

@@ -1,4 +1,5 @@
-import { type Observable } from "rxjs";
+import { Observable } from 'rxjs';
+
 export declare const delayWhenNetworkOnline: <T extends {
     isPaused?: boolean | undefined;
 }>() => (source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/mutations/mutation/executeMutation.d.ts

@@ -1,6 +1,7 @@
-import { type MutationOptions, type MutationState } from "./types";
+import { MutationOptions, MutationState } from './types';
+
 export declare const executeMutation: <TData = unknown, TError = Error, TVariables = void, TContext = unknown>({ variables, state, options }: {
     variables: TVariables;
     state: MutationState<TData, TError, TVariables, TContext>;
     options: MutationOptions<TData, TError, TVariables, TContext>;
-}) => import("rxjs").Observable<MutationState<TData, TError, TVariables, TContext>>;
+}) => import('rxjs').Observable<MutationState<TData, TError, TVariables, TContext>>;

package/dist/lib/queries/client/mutations/mutation/observeUntilFinished.d.ts

@@ -1,3 +1,4 @@
-import { type Observable } from "rxjs";
-import { type MutationState } from "./types";
+import { MutationState } from './types';
+import { Observable } from 'rxjs';
+
 export declare const observeUntilFinished: <T extends MutationState<any, any, any, any>>(source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/mutations/mutation/types.d.ts

@@ -1,7 +1,8 @@
-import { type Observable, type MonoTypeOperatorFunction } from "rxjs";
-import { type DefaultError, type DeprecatedQuery, type QueryResult, type Register } from "../../types";
-import { type MapOperator, type MutationFn, type MutationKey } from "../types";
-import { type NetworkMode } from "../../queries/types";
+import { NetworkMode } from '../../queries/types';
+import { MapOperator, MutationFn, MutationKey } from '../types';
+import { DefaultError, DeprecatedQuery, QueryResult, Register } from '../../types';
+import { Observable, MonoTypeOperatorFunction } from 'rxjs';
+
 export type MutationStatus = "idle" | "pending" | "success" | "error";
 export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
     context: TContext | undefined;

package/dist/lib/queries/client/mutations/mutation/waitForNetworkOnError.d.ts

@@ -1,4 +1,5 @@
-import { type Observable } from "rxjs";
+import { Observable } from 'rxjs';
+
 export declare const waitForNetworkOnError: <T extends {
     failureCount?: number | undefined;
     failureReason?: any;

package/dist/lib/queries/client/mutations/observers/MutationObserver.d.ts

@@ -1,10 +1,11 @@
-import { type Observable } from "rxjs";
-import { type MutateOptions } from "../types";
-import { type QueryClient } from "../../QueryClient";
-import { type DefaultError } from "../../types";
-import { type MutationObserverOptions, type MutationObserverResult } from "./types";
-import { MutationRunner } from "../runner/MutationRunner";
-import { type MutationState } from "../mutation/types";
+import { MutationState } from '../mutation/types';
+import { MutationRunner } from '../runner/MutationRunner';
+import { MutationObserverOptions, MutationObserverResult } from './types';
+import { DefaultError } from '../../types';
+import { QueryClient } from '../../QueryClient';
+import { MutateOptions } from '../types';
+import { Observable } from 'rxjs';
+
 /**
  * Provide API to observe mutations results globally.
  * Observe runners and map their results in a hash map.

package/dist/lib/queries/client/mutations/observers/types.d.ts

@@ -1,6 +1,7 @@
-import { type DefaultError } from "../../types";
-import { type MutationOptions, type MutationState, type MutationStatus } from "../mutation/types";
-import { type MutateFunction } from "../types";
+import { MutateFunction } from '../types';
+import { MutationOptions, MutationState, MutationStatus } from '../mutation/types';
+import { DefaultError } from '../../types';
+
 export interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationOptions<TData, TError, TVariables, TContext> {
     throwOnError?: boolean | ((error: TError) => boolean);
 }

package/dist/lib/queries/client/mutations/runner/MutationRunner.d.ts

@@ -1,8 +1,9 @@
-import { type Observable } from "rxjs";
-import { type DefaultError } from "../../types";
-import { type MutationObserverOptions } from "../observers/types";
-import { type Mutation } from "../mutation/Mutation";
-import { type MutationOptions, type MutationState } from "../mutation/types";
+import { MutationOptions, MutationState } from '../mutation/types';
+import { Mutation } from '../mutation/Mutation';
+import { MutationObserverOptions } from '../observers/types';
+import { DefaultError } from '../../types';
+import { Observable } from 'rxjs';
+
 interface TriggerSubject<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
     args: TVariables;
     options: MutationOptions<TData, TError, TVariables, TContext>;

package/dist/lib/queries/client/mutations/types.d.ts

@@ -1,7 +1,8 @@
-import { type Observable } from "rxjs";
-import { type DefaultError } from "../types";
-import { type Mutation } from "./mutation/Mutation";
-import { type MutationStatus } from "./mutation/types";
+import { MutationStatus } from './mutation/types';
+import { Mutation } from './mutation/Mutation';
+import { DefaultError } from '../types';
+import { Observable } from 'rxjs';
+
 /**
  * The default value `merge` is suitable for most use case.
  * You should not have to worry too much about it and only consider changing

package/dist/lib/queries/client/onlineManager.d.ts

@@ -1,8 +1,9 @@
-import { BehaviorSubject } from "rxjs";
+import { BehaviorSubject } from 'rxjs';
+
 export declare class OnlineManager {
     protected isOnlineSubject: BehaviorSubject<boolean>;
-    readonly online$: import("rxjs").Observable<boolean>;
-    readonly backToOnline$: import("rxjs").Observable<boolean>;
+    readonly online$: import('rxjs').Observable<boolean>;
+    readonly backToOnline$: import('rxjs').Observable<boolean>;
     constructor();
     isOnline(): boolean;
     setOnline(online: boolean): void;

package/dist/lib/queries/client/queries/cache/QueryCache.d.ts

@@ -1,11 +1,12 @@
-import { type DefaultError } from "../../types";
-import { type QueryKey } from "../../keys/types";
-import { Query } from "../query/Query";
-import { type QueryOptions, type QueryFilters } from "../types";
-import { type QueryClient } from "../../QueryClient";
-import { type QueryState } from "../query/types";
-import { type WithRequired } from "../../../../utils/types";
-import { type QueryCacheConfig, type QueryCacheListener } from "./types";
+import { QueryCacheConfig, QueryCacheListener } from './types';
+import { WithRequired } from '../../../../utils/types';
+import { QueryState } from '../query/types';
+import { QueryClient } from '../../QueryClient';
+import { QueryOptions, QueryFilters } from '../types';
+import { Query } from '../query/Query';
+import { QueryKey } from '../../keys/types';
+import { DefaultError } from '../../types';
+
 export interface QueryStore {
     has: (queryHash: string) => boolean;
     set: (queryHash: string, query: Query) => void;
@@ -20,7 +21,7 @@ export declare class QueryCache {
     mount(): void;
     unmount(): void;
     notify(event: Parameters<QueryCacheListener>[0]): void;
-    observeIsFetching(filters?: QueryFilters): import("rxjs").Observable<number>;
+    observeIsFetching(filters?: QueryFilters): import('rxjs').Observable<number>;
     getAll(): Query[];
     findAll(filters?: QueryFilters): Query[];
     build<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(client: QueryClient, options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, state?: QueryState<TData, TError>): Query<TQueryFnData, TError, TData, TQueryKey>;

package/dist/lib/queries/client/queries/cache/types.d.ts

@@ -1,8 +1,9 @@
-import { type NotifyEvent } from "../../mutations/cache/types";
-import { type DefaultError } from "../../types";
-import { type QueryObserver } from "../observer/QueryObserver";
-import { type Query } from "../query/Query";
-import { type Action } from "../query/types";
+import { Action } from '../query/types';
+import { Query } from '../query/Query';
+import { QueryObserver } from '../observer/QueryObserver';
+import { DefaultError } from '../../types';
+import { NotifyEvent } from '../../mutations/cache/types';
+
 export interface QueryCacheConfig {
     onError?: (error: DefaultError, query: Query<unknown, unknown, unknown>) => void;
     onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;

package/dist/lib/queries/client/queries/observer/QueryObserver.d.ts

@@ -1,11 +1,12 @@
-import { type Observable, Subject } from "rxjs";
-import { type QueryClient } from "../../QueryClient";
-import { type QueryKey } from "../../keys/types";
-import { type DefaultError } from "../../types";
-import { type Query } from "../query/Query";
-import { type FetchOptions } from "../query/types";
-import { type RefetchOptions } from "../types";
-import { type QueryObserverResult, type QueryObserverOptions, type DefaultedQueryObserverOptions, type QueryObserverListener } from "./types";
+import { QueryObserverResult, QueryObserverOptions, DefaultedQueryObserverOptions, QueryObserverListener } from './types';
+import { RefetchOptions } from '../types';
+import { FetchOptions } from '../query/types';
+import { Query } from '../query/Query';
+import { DefaultError } from '../../types';
+import { QueryKey } from '../../keys/types';
+import { QueryClient } from '../../QueryClient';
+import { Observable, Subject } from 'rxjs';
+
 export interface ObserverFetchOptions extends FetchOptions {
     throwOnError?: boolean;
 }
@@ -39,7 +40,7 @@ export declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError
     protected getObserverResultFromQuery: ({ options, query, optimisticResult, prevResult: { result: prevResult, options: prevResultOptions, state: prevResultState, select: prevSelect, selectError: prevSelectError, selectResult: prevSelectResult } }: {
         query: Query<TQueryFnData, TError, TQueryData, TQueryKey>;
         options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
-        optimisticResult?: boolean | undefined;
+        optimisticResult?: boolean;
         prevResult: Partial<LastResult<TQueryFnData, TError, TData, TQueryData, TQueryKey>>;
     }) => {
         result: QueryObserverResult<TData, TError>;

package/dist/lib/queries/client/queries/observer/queryStateHelpers.d.ts

@@ -1,6 +1,7 @@
-import { type Query } from "../query/Query";
-import { type NetworkMode } from "../types";
-import { type QueryObserverOptions } from "./types";
+import { QueryObserverOptions } from './types';
+import { NetworkMode } from '../types';
+import { Query } from '../query/Query';
+
 export declare function isStale(query: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>): boolean;
 export declare function shouldFetchOnMount(query: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>): boolean;
 export declare function shouldFetchOptionally(query: Query<any, any, any, any>, prevQuery: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>, prevOptions: QueryObserverOptions<any, any, any, any, any>): boolean;

package/dist/lib/queries/client/queries/observer/types.d.ts

@@ -1,8 +1,9 @@
-import { type NonFunctionGuard, type WithRequired } from "../../../../utils/types";
-import { type QueryKey } from "../../keys/types";
-import { type DefaultError } from "../../types";
-import { type Query } from "../query/Query";
-import { type ThrowOnError, type QueryOptions, type PlaceholderDataFunction, type NotifyOnChangeProps, type RefetchOptions, type QueryStatus, type FetchStatus, type FetchNextPageOptions, type FetchPreviousPageOptions } from "../types";
+import { ThrowOnError, QueryOptions, PlaceholderDataFunction, NotifyOnChangeProps, RefetchOptions, QueryStatus, FetchStatus, FetchNextPageOptions, FetchPreviousPageOptions } from '../types';
+import { Query } from '../query/Query';
+import { DefaultError } from '../../types';
+import { QueryKey } from '../../keys/types';
+import { NonFunctionGuard, WithRequired } from '../../../../utils/types';
+
 export interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam> {
     /**
      * Set this to `false` to disable automatic refetching when the query mounts or changes query keys.

package/dist/lib/queries/client/queries/query/Query.d.ts

@@ -1,11 +1,12 @@
-import { type Observable, Subject, BehaviorSubject } from "rxjs";
-import { type QueryKey } from "../../keys/types";
-import { type DefaultError } from "../../types";
-import { type QueryCache } from "../cache/QueryCache";
-import { type SetDataOptions, type QueryOptions } from "../types";
-import { type QueryMeta, type FetchOptions, type QueryState } from "./types";
-import { type CancelOptions } from "../retryer/types";
-import { type QueryObserver } from "../observer/QueryObserver";
+import { QueryObserver } from '../observer/QueryObserver';
+import { CancelOptions } from '../retryer/types';
+import { QueryMeta, FetchOptions, QueryState } from './types';
+import { SetDataOptions, QueryOptions } from '../types';
+import { QueryCache } from '../cache/QueryCache';
+import { DefaultError } from '../../types';
+import { QueryKey } from '../../keys/types';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+
 interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
     cache: QueryCache;
     queryKey: TQueryKey;
@@ -42,14 +43,14 @@ export declare class Query<TQueryFnData = unknown, TError = DefaultError, TData
     get meta(): QueryMeta | undefined;
     get success$(): Observable<{
         data: TData | undefined;
-        status: import("../types").QueryStatus;
+        status: import('../types').QueryStatus;
     }>;
     get error$(): Observable<{
         error: TError | null;
-        status: import("../types").QueryStatus;
+        status: import('../types').QueryStatus;
     }>;
     get settled$(): Observable<{
-        status: import("../types").QueryStatus;
+        status: import('../types').QueryStatus;
     }>;
     observe(observer: QueryObserver<any, any, any, any, any>): Observable<QueryState<TData, TError>>;
     getObserversCount(): number;

package/dist/lib/queries/client/queries/query/delayOnNetworkMode.d.ts

@@ -1,6 +1,7 @@
-import { type Observable } from "rxjs";
-import { type QueryOptions } from "../types";
-import { type QueryState } from "./types";
+import { QueryState } from './types';
+import { QueryOptions } from '../types';
+import { Observable } from 'rxjs';
+
 type Result<TData, TError> = Partial<QueryState<TData, TError>>;
-export declare const delayOnNetworkMode: <TData, TError>(options: Pick<QueryOptions, "networkMode">) => (source: Observable<Partial<QueryState<TData, TError>>>) => Observable<Partial<QueryState<TData, TError>>>;
+export declare const delayOnNetworkMode: <TData, TError>(options: Pick<QueryOptions, "networkMode">) => (source: Observable<Result<TData, TError>>) => Observable<Result<TData, TError>>;
 export {};

package/dist/lib/queries/client/queries/query/delayUntilFocus.d.ts

@@ -1,2 +1,3 @@
-import { type Observable } from "rxjs";
+import { Observable } from 'rxjs';
+
 export declare const delayUntilFocus: <T>(source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/queries/query/execution/completeFnIfNotMoreObservers.d.ts

@@ -1,2 +1,3 @@
-import { type MonoTypeOperatorFunction, type Observable } from "rxjs";
+import { MonoTypeOperatorFunction, Observable } from 'rxjs';
+
 export declare const completeFnIfNotMoreObservers: <T>(observers$: Observable<number>) => MonoTypeOperatorFunction<T>;

package/dist/lib/queries/client/queries/query/execution/executeQuery.d.ts

@@ -1,8 +1,9 @@
-import { type Observable } from "rxjs";
-import { type QueryKey } from "../../../keys/types";
-import { type QueryState } from "../types";
-import { type QueryOptions } from "../../types";
-export declare const executeQuery: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: QueryOptions<TQueryFnData, TError, TData, TQueryKey, never> & {
+import { QueryOptions } from '../../types';
+import { QueryState } from '../types';
+import { QueryKey } from '../../../keys/types';
+import { Observable } from 'rxjs';
+
+export declare const executeQuery: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: QueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     queryKey: TQueryKey;
     onSignalConsumed: () => void;
     observers$: Observable<number>;

package/dist/lib/queries/client/queries/query/getDefaultState.d.ts

@@ -1,4 +1,5 @@
-import { type QueryKey } from "../../keys/types";
-import { type QueryOptions } from "../types";
-import { type QueryState } from "./types";
+import { QueryState } from './types';
+import { QueryOptions } from '../types';
+import { QueryKey } from '../../keys/types';
+
 export declare function getDefaultState<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): QueryState<TData, TError>;

package/dist/lib/queries/client/queries/query/operators.d.ts

@@ -1,10 +1,11 @@
-import { type Observable } from "rxjs";
-import { type QueryOptions } from "../types";
-import { type QueryState } from "./types";
+import { QueryState } from './types';
+import { QueryOptions } from '../types';
+import { Observable } from 'rxjs';
+
 export declare const reduceState: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData>({ getOptions, getState, initialState }: {
     initialState: QueryState<TData, TError>;
     getState: () => QueryState<TData, TError>;
-    getOptions: () => QueryOptions<TQueryFnData, TError, TData, any, never>;
+    getOptions: () => QueryOptions<TQueryFnData, TError, TData, any>;
 }) => (source: Observable<{
     command: "invalidate" | "cancel" | "reset" | "setData" | "execute";
     state: Partial<QueryState<TData, TError>>;