reactjrx 1.82.0 → 1.86.0

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

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

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

@@ -1,6 +1,6 @@
 import { CancelOptions } from './queries/retryer/types';
 import { QueryState } from './queries/query/types';
-import { NoInfer } from '../../utils/types';
+import { NoInfer, OmitKeyof } from '../../utils/types';
 import { DefaultedQueryObserverOptions, QueryObserverOptions } from './queries/observer/types';
 import { QueryKey } from './keys/types';
 import { RefetchQueryFilters, DefaultError, InvalidateOptions, InvalidateQueryFilters, ResetOptions } from './types';
@@ -12,7 +12,7 @@ import { MutationCache } from './mutations/cache/MutationCache';
 import { MutationKey } from './mutations/types';
 
 export interface DefaultOptions<TError = DefaultError> {
-    queries?: Omit<QueryObserverOptions<unknown, TError>, "suspense">;
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, "suspense" | "queryKey">;
     mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
 }
 export interface QueryClientConfig {
@@ -28,18 +28,18 @@ export declare class QueryClient {
     getMutationCache(): MutationCache;
     getQueryCache(): QueryCache;
     defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
-    defaultQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
-    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
+    defaultQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> | QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> | FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
     prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
     resetQueries(filters?: QueryFilters, options?: ResetOptions): Promise<void>;
     refetchQueries(filters?: RefetchQueryFilters, options?: RefetchOptions): Promise<void>;
     getQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData>(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined;
-    setQueryData<TQueryFnData = unknown, TaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = TaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData>(queryKey: TaggedQueryKey, updater: Updater<NoInfer<TInferredQueryFnData> | undefined, NoInfer<TInferredQueryFnData> | undefined>, options?: SetDataOptions): TInferredQueryFnData | undefined;
+    setQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData>(queryKey: TTaggedQueryKey, updater: Updater<NoInfer<TInferredQueryFnData> | undefined, NoInfer<TInferredQueryFnData> | undefined>, options?: SetDataOptions): TInferredQueryFnData | undefined;
     getMutationDefaults(mutationKey: MutationKey): MutationObserverOptions<any, any, any, any>;
-    getQueryState<TQueryFnData = unknown, TError = DefaultError>(queryKey: QueryKey): QueryState<TQueryFnData, TError> | undefined;
+    getQueryState<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData>(queryKey: TTaggedQueryKey): QueryState<TInferredQueryFnData, TError> | undefined;
     setMutationDefaults(mutationKey: MutationKey, options: Omit<MutationObserverOptions<any, any, any, any>, "mutationKey">): void;
     setQueryDefaults(queryKey: QueryKey, options: Partial<Omit<QueryObserverOptions<unknown, any, any, any>, "queryKey">>): void;
-    getQueryDefaults(queryKey: QueryKey): QueryObserverOptions<any, any, any, any, any>;
+    getQueryDefaults(queryKey: QueryKey): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, "queryKey">;
     removeQueries(filters?: QueryFilters): void;
     cancelQueries(filters?: QueryFilters, cancelOptions?: CancelOptions): Promise<void>;
     invalidateQueries(filters?: InvalidateQueryFilters, options?: InvalidateOptions): Promise<void>;

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

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

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

@@ -26,6 +26,11 @@ export declare class Mutation<TData = unknown, TError = DefaultError, TVariables
      */
     execute(variables: TVariables): Observable<MutationState<TData, TError, TVariables, TContext>>;
     continue(): Observable<MutationState<TData, TError, TVariables, TContext>>;
+    /**
+     * Cancel if needed and finalize the mutation.
+     * The mutation will be garbage collected automatically
+     * when no more observers are listening
+     */
     cancel(): void;
 }
 export {};

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

@@ -11,7 +11,10 @@ interface TriggerSubject<TData, TError = DefaultError, TVariables = void, TConte
 }
 export declare class MutationRunner<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
     #private;
-    state$: Observable<MutationState<TData, TError, TVariables, TContext>>;
+    state$: Observable<{
+        state: MutationState<TData, TError, TVariables, TContext>;
+        mutation: Mutation<TData, TError, TVariables, TContext>;
+    }>;
     constructor({ __queryFinalizeHook }?: MutationObserverOptions<TData, TError, TVariables, TContext>);
     trigger({ args, options, mutation }: TriggerSubject<TData, TError, TVariables, TContext>): void;
 }

package/dist/lib/queries/client/mutations/{defaultMutationState.d.ts → utils/defaultMutationState.d.ts}

@@ -1,3 +1,3 @@
-import { 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/utils/distinctUntilStateChanged.d.ts

@@ -0,0 +1,4 @@
+import { MutationState } from '../mutation/types';
+import { Observable } from 'rxjs';
+
+export declare const distinctUntilStateChanged: <State extends MutationState<any, any, any, any>>(stream: Observable<State>) => Observable<State>;

package/dist/lib/queries/client/mutations/{filters.d.ts → utils/filters.d.ts}

@@ -1,3 +1,3 @@
-import { MutationFilters } from './types';
+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;
+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/queries/cache/QueryCache.d.ts

@@ -24,7 +24,7 @@ export declare class QueryCache {
     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>;
+    build<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(client: QueryClient, options: WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey>, "queryKey">, state?: QueryState<TData, TError>): Query<TQueryFnData, TError, TData, TQueryKey>;
     add(query: Query<any, any, any, any>): void;
     get<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryHash: string): Query<TQueryFnData, TError, TData, TQueryKey> | undefined;
     find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: WithRequired<QueryFilters, "queryKey">): Query<TQueryFnData, TError, TData> | undefined;

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

@@ -35,12 +35,12 @@ export declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError
     }>;
     constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
     protected bindMethods(): void;
-    setOptions(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
-    protected buildQuery(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    setOptions(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Query<TQueryFnData, TError, TQueryData, TQueryKey & {}>;
+    protected buildQuery(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Query<TQueryFnData, TError, TQueryData, TQueryKey & {}>;
     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;
+        optimisticResult?: boolean | undefined;
         prevResult: Partial<LastResult<TQueryFnData, TError, TData, TQueryData, TQueryKey>>;
     }) => {
         result: QueryObserverResult<TData, TError>;

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

@@ -4,7 +4,7 @@ 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> {
+export 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"> {
     /**
      * Set this to `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.
@@ -45,7 +45,7 @@ export interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultEr
     refetchOnReconnect?: boolean | "idle" | "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 refetches.
+     * 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 `'always'`, the query will always refetch on mount if idle.
      * If set to a function, the function will be executed with the latest data and query to compute the value

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

@@ -3,5 +3,5 @@ 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<Result<TData, TError>>) => Observable<Result<TData, TError>>;
+export declare const delayOnNetworkMode: <TData, TError>(options: Pick<QueryOptions, "networkMode">) => (source: Observable<Partial<QueryState<TData, TError>>>) => Observable<Partial<QueryState<TData, TError>>>;
 export {};

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

@@ -3,7 +3,7 @@ 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> & {
+export declare const executeQuery: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: QueryOptions<TQueryFnData, TError, TData, TQueryKey, never> & {
     queryKey: TQueryKey;
     onSignalConsumed: () => void;
     observers$: Observable<number>;

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

@@ -5,7 +5,7 @@ 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>;
+    getOptions: () => QueryOptions<TQueryFnData, TError, TData, any, never>;
 }) => (source: Observable<{
     command: "invalidate" | "cancel" | "reset" | "setData" | "execute";
     state: Partial<QueryState<TData, TError>>;

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

@@ -29,6 +29,8 @@ export type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPagePar
     queryKey: TQueryKey;
     signal: AbortSignal;
     meta: QueryMeta | undefined;
+    pageParam?: unknown;
+    direction?: "forward" | "backward";
 } : {
     queryKey: TQueryKey;
     signal: AbortSignal;

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

@@ -1,3 +1,4 @@
+import { SkipToken } from './utils';
 import { QueryMeta, QueryFunction, QueryFunctionContext, QueryBehavior } from './query/types';
 import { Query } from './query/Query';
 import { InfiniteQueryObserverResult } from './observer/types';
@@ -6,8 +7,8 @@ import { QueryKey } from '../keys/types';
 import { NoInfer, WithRequired } from '../../../utils/types';
 
 export declare const dataTagSymbol: unique symbol;
-export type DataTag<Type, Value> = Type & {
-    [dataTagSymbol]: Value;
+export type DataTag<TType, TValue> = TType & {
+    [dataTagSymbol]: TValue;
 };
 export type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
 export interface SetDataOptions {
@@ -50,7 +51,7 @@ export interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
      * Setting it to `Infinity` will disable garbage collection.
      */
     gcTime?: number;
-    queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
+    queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken;
     persister?: QueryPersister<NoInfer<TQueryFnData>, NoInfer<TQueryKey>, NoInfer<TPageParam>>;
     queryHash?: string;
     queryKey?: TQueryKey;
@@ -63,7 +64,7 @@ export interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
      * 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 | (<T>(oldData: T | undefined, newData: T) => T);
+    structuralSharing?: boolean | ((oldData: unknown | undefined, newData: unknown) => unknown);
     _defaulted?: boolean;
     /**
      * Additional payload to be stored on each query.

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

@@ -2,8 +2,10 @@ import { QueryOptions, QueryFilters, Updater } from './types';
 import { Query } from './query/Query';
 import { QueryKey } from '../keys/types';
 
-export declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: QueryOptions<any, any, any, TQueryKey>): string;
+export declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Pick<QueryOptions<any, any, any, any>, "queryKeyHashFn">): string;
 export declare function matchQuery(filters: QueryFilters, query: Query<any, any, any, any>): boolean;
 export declare function timeUntilStale(updatedAt: number, staleTime?: number): number;
 export declare function functionalUpdate<TInput, TOutput>(updater: Updater<TInput, TOutput>, input: TInput): TOutput;
 export declare function replaceData<TData, TOptions extends QueryOptions<any, any, any, any>>(prevData: TData | undefined, data: TData, options: TOptions): TData;
+export declare const skipToken: unique symbol;
+export type SkipToken = typeof skipToken;

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

@@ -75,7 +75,7 @@ export interface RefetchOptions extends ResultOptions {
     cancelRefetch?: boolean;
 }
 export interface InvalidateQueryFilters extends QueryFilters {
-    refetchType?: QueryTypeFilter | 'none';
+    refetchType?: QueryTypeFilter | "none";
 }
 export interface InvalidateOptions extends RefetchOptions {
 }

package/dist/lib/queries/react/mutations/useIsMutating.d.ts

@@ -1,4 +1,4 @@
 import { QueryClient } from '../../client/QueryClient';
 import { MutationFilters } from '../../client/mutations/types';
 
-export declare const useIsMutating: <TData>(filters?: MutationFilters<TData>, queryClient?: QueryClient) => number;
+export declare const useIsMutating: <TData>(filters?: MutationFilters<TData, Error, any, unknown>, queryClient?: QueryClient) => number;

package/dist/lib/queries/react/queries/QueryOptions.rq.types.typeTest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/queries/react/queries/isRestoring.d.ts

@@ -1,3 +1,3 @@
-import * as React from 'react';
+import * as React from "react";
 export declare const useIsRestoring: () => boolean;
 export declare const IsRestoringProvider: React.Provider<boolean>;

package/dist/lib/queries/react/queries/queryOptions.d.ts

@@ -3,17 +3,17 @@ import { DefaultError } from '../../client/types';
 import { DataTag } from '../../client/queries/types';
 import { QueryKey } from '../../client/keys/types';
 
-export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
     initialData?: undefined;
 };
 type NonUndefinedGuard<T> = T extends undefined ? never : T;
 export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
 };
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
     queryKey: DataTag<TQueryKey, TQueryFnData>;
 };
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
     queryKey: DataTag<TQueryKey, TQueryFnData>;
 };
 export {};

package/dist/lib/queries/react/queries/types.d.ts

@@ -1,12 +1,12 @@
 import { DefaultError } from '../../client/types';
 import { QueryObserverResult, DefinedQueryObserverResult, QueryObserverOptions } from '../../client/queries/observer/types';
 import { QueryKey } from '../../client/keys/types';
-import { WithRequired } from '../../../utils/types';
+import { OmitKeyof } from '../../../utils/types';
 
 export type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
-export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, "queryKey"> {
+export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> {
 }
-export interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Omit<WithRequired<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, "queryKey">, "suspense"> {
+export interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, "suspense"> {
 }
 export type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
 export type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;

package/dist/lib/state/persistance/adapters/createLocalStorageAdapter.d.ts

@@ -1,5 +1,5 @@
 import { Adapter } from '../types';
 
 export declare const createLocalStorageAdapter: ({ key }?: {
-    key?: string;
+    key?: string | undefined;
 }) => Adapter;

package/dist/lib/state/persistance/usePersistSignals.d.ts

@@ -2,17 +2,17 @@ import { Signal } from '../signal';
 import { Adapter } from './types';
 
 export declare const usePersistSignals: ({ entries, onReady, adapter }: {
-    entries?: Array<{
+    entries?: {
         version: number;
         signal: Signal<any, any, string>;
-    }>;
-    onReady?: () => void;
+    }[] | undefined;
+    onReady?: (() => void) | undefined;
     /**
      * Requires a stable instance otherwise the hydration
      * process will start again. This is useful when you
      * need to change adapter during runtime.
      */
-    adapter?: Adapter;
+    adapter?: Adapter | undefined;
 }) => {
     isHydrated: boolean;
 };

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

@@ -1,7 +1,8 @@
-export type WithRequired<T, K extends keyof T> = T & {
-    [_ in K]: {};
+export type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & {
+    [_ in TKey]: {};
 };
 export type NonFunctionGuard<T> = T extends Function ? never : T;
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export type Expect<T extends true> = T;
+export type OmitKeyof<TObject, TKey extends TStrictly extends "safely" ? keyof TObject | (string & Record<never, never>) : keyof TObject, TStrictly extends "strictly" | "safely" = "strictly"> = Omit<TObject, TKey>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.82.0",
+  "version": "1.86.0",
   "type": "module",
   "files": [
     "dist"
@@ -60,7 +60,7 @@
     "rollup-plugin-node-externals": "^7.0.1",
     "rxjs": "^7.8.0",
     "semantic-release": "^23.0.2",
-    "typescript": "^5.0.4",
+    "typescript": "5.2.2",
     "vite": "^5.1.3",
     "vite-plugin-dts": "^3.6.3",
     "vitest": "^1.3.0"