infinity-forge 9.7.2 → 9.7.3

package/dist/use-query/src/query-core/src/utils.d.ts

@@ -1,93 +0,0 @@
-import { DefaultError, Enabled, FetchStatus, MutationKey, MutationStatus, QueryFunction, QueryKey, QueryOptions, StaleTime } from './types';
-import { Mutation } from './mutation';
-import { FetchOptions, Query } from './query';
-export interface QueryFilters<TQueryKey extends QueryKey = QueryKey> {
-    /**
-     * Filter to active queries, inactive queries or all queries
-     */
-    type?: QueryTypeFilter;
-    /**
-     * Match query key exactly
-     */
-    exact?: boolean;
-    /**
-     * Include queries matching this predicate function
-     */
-    predicate?: (query: Query) => boolean;
-    /**
-     * Include queries matching this query key
-     */
-    queryKey?: TQueryKey;
-    /**
-     * Include or exclude stale queries
-     */
-    stale?: boolean;
-    /**
-     * Include queries matching their fetchStatus
-     */
-    fetchStatus?: FetchStatus;
-}
-export interface MutationFilters<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> {
-    /**
-     * Match mutation key exactly
-     */
-    exact?: boolean;
-    /**
-     * Include mutations matching this predicate function
-     */
-    predicate?: (mutation: Mutation<TData, TError, TVariables, TContext>) => boolean;
-    /**
-     * Include mutations matching this mutation key
-     */
-    mutationKey?: MutationKey;
-    /**
-     * Filter by mutation status
-     */
-    status?: MutationStatus;
-}
-export type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
-export type QueryTypeFilter = 'all' | 'active' | 'inactive';
-export declare const isServer: boolean;
-export declare function noop(): void;
-export declare function noop(): undefined;
-export declare function functionalUpdate<TInput, TOutput>(updater: Updater<TInput, TOutput>, input: TInput): TOutput;
-export declare function isValidTimeout(value: unknown): value is number;
-export declare function timeUntilStale(updatedAt: number, staleTime?: number): number;
-export declare function resolveStaleTime<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(staleTime: undefined | StaleTime<TQueryFnData, TError, TData, TQueryKey>, query: Query<TQueryFnData, TError, TData, TQueryKey>): number | undefined;
-export declare function resolveEnabled<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(enabled: undefined | Enabled<TQueryFnData, TError, TData, TQueryKey>, query: Query<TQueryFnData, TError, TData, TQueryKey>): boolean | undefined;
-export declare function matchQuery(filters: QueryFilters, query: Query<any, any, any, any>): boolean;
-export declare function matchMutation(filters: MutationFilters, mutation: Mutation<any, any>): boolean;
-export declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Pick<QueryOptions<any, any, any, any>, 'queryKeyHashFn'>): string;
-/**
- * Default query & mutation keys hash function.
- * Hashes the value into a stable hash.
- */
-export declare function hashKey(queryKey: QueryKey | MutationKey): string;
-/**
- * Checks if key `b` partially matches with key `a`.
- */
-export declare function partialMatchKey(a: QueryKey, b: QueryKey): boolean;
-/**
- * This function returns `a` if `b` is deeply equal.
- * If not, it will replace any deeply equal children of `b` with those of `a`.
- * This can be used for structural sharing between JSON values for example.
- */
-export declare function replaceEqualDeep<T>(a: unknown, b: T): T;
-/**
- * Shallow compare objects.
- */
-export declare function shallowEqualObjects<T extends Record<string, any>>(a: T, b: T | undefined): boolean;
-export declare function isPlainArray(value: unknown): boolean;
-export declare function isPlainObject(o: any): o is Object;
-export declare function sleep(timeout: number): Promise<void>;
-export declare function replaceData<TData, TOptions extends QueryOptions<any, any, any, any>>(prevData: TData | undefined, data: TData, options: TOptions): TData;
-export declare function keepPreviousData<T>(previousData: T | undefined): T | undefined;
-export declare function addToEnd<T>(items: Array<T>, item: T, max?: number): Array<T>;
-export declare function addToStart<T>(items: Array<T>, item: T, max?: number): Array<T>;
-export declare const skipToken: unique symbol;
-export type SkipToken = typeof skipToken;
-export declare function ensureQueryFn<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey>(options: {
-    queryFn?: QueryFunction<TQueryFnData, TQueryKey> | SkipToken;
-    queryHash?: string;
-}, fetchOptions?: FetchOptions<TQueryFnData>): QueryFunction<TQueryFnData, TQueryKey>;
-export declare function shouldThrowError<T extends (...args: Array<any>) => boolean>(throwOnError: boolean | T | undefined, params: Parameters<T>): boolean;

package/dist/use-query/src/queryOptions.d.ts

@@ -1,23 +0,0 @@
-import { DataTag, DefaultError, InitialDataFunction, OmitKeyof, QueryFunction, QueryKey, SkipToken } from './query-core/src';
-import { UseQueryOptions } from './types';
-export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
-};
-export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
-    queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken | undefined>;
-};
-type NonUndefinedGuard<T> = T extends undefined ? never : T;
-export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
-    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
-    queryFn?: QueryFunction<TQueryFnData, 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, TError>;
-};
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
-};
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
-};
-export {};

package/dist/use-query/src/suspense.d.ts

@@ -1,7 +0,0 @@
-import { DefaultError, DefaultedQueryObserverOptions, Query, QueryKey, QueryObserver, QueryObserverResult } from './query-core/src';
-import { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary';
-export declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;
-export declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;
-export declare const willFetch: (result: QueryObserverResult<any, any>, isRestoring: boolean) => boolean;
-export declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> | undefined, result: QueryObserverResult<any, any>) => boolean;
-export declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void | QueryObserverResult<TData, TError>>;

package/dist/use-query/src/types.d.ts

@@ -1,46 +0,0 @@
-import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, DistributiveOmit, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken } from './query-core/src';
-export type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
-export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-    /**
-     * Set this to `false` to unsubscribe this observer from updates to the query cache.
-     * Defaults to `true`.
-     */
-    subscribed?: boolean;
-}
-export type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
-export interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
-}
-export type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
-export interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'> {
-    queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
-}
-export type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any, any>;
-export interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'suspense'> {
-    /**
-     * Set this to `false` to unsubscribe this observer from updates to the query cache.
-     * Defaults to `true`.
-     */
-    subscribed?: boolean;
-}
-export type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any, any>;
-export interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'> {
-    queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
-}
-export type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
-export type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
-export type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData' | 'promise'>;
-export type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
-export type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
-export type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
-export type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData' | 'promise'>;
-export type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
-export interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
-}
-export type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-export type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-export type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
-    mutate: UseMutateFunction<TData, TError, TVariables, TContext>;
-}> & {
-    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
-};
-export type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = UseBaseMutationResult<TData, TError, TVariables, TContext>;

package/dist/use-query/src/useBaseQuery.d.ts

@@ -1,3 +0,0 @@
-import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from './query-core/src';
-import { UseBaseQueryOptions } from './types';
-export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;

package/dist/use-query/src/useInfiniteQuery.d.ts

@@ -1,6 +0,0 @@
-import { DefaultError, InfiniteData, QueryClient, QueryKey } from './query-core/src';
-import { DefinedUseInfiniteQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult } from './types';
-import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from './infiniteQueryOptions';
-export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
-export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
-export declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;

package/dist/use-query/src/useIsFetching.d.ts

@@ -1,2 +0,0 @@
-import { QueryClient, QueryFilters } from './query-core/src';
-export declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;

package/dist/use-query/src/useMutation.d.ts

@@ -1,3 +0,0 @@
-import { UseMutationOptions, UseMutationResult } from './types';
-import { DefaultError, QueryClient } from './query-core/src';
-export declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TContext>;

package/dist/use-query/src/useMutationState.d.ts

@@ -1,8 +0,0 @@
-import { Mutation, MutationFilters, MutationState, QueryClient } from './query-core/src';
-export declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
-type MutationStateOptions<TResult = MutationState> = {
-    filters?: MutationFilters;
-    select?: (mutation: Mutation) => TResult;
-};
-export declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult>, queryClient?: QueryClient): Array<TResult>;
-export {};

package/dist/use-query/src/usePrefetchInfiniteQuery.d.ts

@@ -1,2 +0,0 @@
-import { DefaultError, FetchInfiniteQueryOptions, QueryClient, QueryKey } from './query-core/src';
-export declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;

package/dist/use-query/src/usePrefetchQuery.d.ts

@@ -1,2 +0,0 @@
-import { DefaultError, FetchQueryOptions, QueryClient, QueryKey } from './query-core/src';
-export declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): void;

package/dist/use-query/src/useQueries.d.ts

@@ -1,74 +0,0 @@
-import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
-import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from './query-core/src';
-type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'subscribed'> & {
-    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
-};
-type MAXIMUM_DEPTH = 20;
-type SkipTokenForUseQueries = symbol;
-type GetUseQueryOptionsForUseQueries<T> = T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-    data: infer TData;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
-    select?: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
-type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
-    initialData?: infer TInitialData;
-} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
-type GetUseQueryResult<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
-} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
-    select?: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- */
-export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
-    ...Tails
-], [
-    ...TResults,
-    GetUseQueryOptionsForUseQueries<Head>
-], [
-    ...TDepth,
-    1
-]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
-/**
- * QueriesResults reducer recursively maps type param to results
- */
-export type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
-    ...Tails
-], [
-    ...TResults,
-    GetUseQueryResult<Head>
-], [
-    ...TDepth,
-    1
-]> : {
-    [K in keyof T]: GetUseQueryResult<T[K]>;
-};
-export declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
-    queries: readonly [...QueriesOptions<T>] | readonly [...{
-        [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
-    }];
-    combine?: (result: QueriesResults<T>) => TCombinedResult;
-    subscribed?: boolean;
-}, queryClient?: QueryClient): TCombinedResult;
-export {};

package/dist/use-query/src/useQuery.d.ts

@@ -1,6 +0,0 @@
-import { DefaultError, NoInfer, QueryClient, QueryKey } from './query-core/src';
-import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
-import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './queryOptions';
-export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<NoInfer<TData>, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;

package/dist/use-query/src/useSuspenseInfiniteQuery.d.ts

@@ -1,3 +0,0 @@
-import { DefaultError, InfiniteData, QueryClient, QueryKey } from './query-core/src';
-import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from './types';
-export declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;

package/dist/use-query/src/useSuspenseQueries.d.ts

@@ -1,77 +0,0 @@
-import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types';
-import { DefaultError, QueryClient, QueryFunction, ThrowOnError } from './query-core/src';
-type MAXIMUM_DEPTH = 20;
-type SkipTokenForUseQueries = symbol;
-type GetUseSuspenseQueryOptions<T> = T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-    data: infer TData;
-} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
-    select?: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
-type GetUseSuspenseQueryResult<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
-} ? UseSuspenseQueryResult<TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
-    select?: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
-/**
- * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- */
-export type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[
-    ...Tails
-], [
-    ...TResults,
-    GetUseSuspenseQueryOptions<Head>
-], [
-    ...TDepth,
-    1
-]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
-/**
- * SuspenseQueriesResults reducer recursively maps type param to results
- */
-export type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[
-    ...Tails
-], [
-    ...TResults,
-    GetUseSuspenseQueryResult<Head>
-], [
-    ...TDepth,
-    1
-]> : {
-    [K in keyof T]: GetUseSuspenseQueryResult<T[K]>;
-};
-export declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
-    queries: readonly [...SuspenseQueriesOptions<T>] | readonly [...{
-        [K in keyof T]: GetUseSuspenseQueryOptions<T[K]>;
-    }];
-    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
-}, queryClient?: QueryClient): TCombinedResult;
-export declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
-    queries: readonly [...SuspenseQueriesOptions<T>];
-    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
-}, queryClient?: QueryClient): TCombinedResult;
-export {};

package/dist/use-query/src/useSuspenseQuery.d.ts

@@ -1,3 +0,0 @@
-import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types';
-import { DefaultError, QueryClient, QueryKey } from './query-core/src';
-export declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;

package/dist/use-query/use-mutation.d.ts

@@ -1,2 +0,0 @@
-import { useQueryProps } from './hook';
-export declare function useMutation<T>(props: useQueryProps<T>): Required<import('./interfaces').QueryState<Awaited<T>>>;