@octanejs/tanstack-query 0.1.2

package/src/mutationOptions.ts

@@ -0,0 +1,33 @@
+// Verbatim port of @tanstack/react-query's mutationOptions.ts — a typed identity helper
+import type { DefaultError, WithRequired } from '@tanstack/query-core';
+import type { UseMutationOptions } from './types';
+
+export function mutationOptions<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = void,
+	TOnMutateResult = unknown,
+>(
+	options: WithRequired<
+		UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+		'mutationKey'
+	>,
+): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export function mutationOptions<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = void,
+	TOnMutateResult = unknown,
+>(
+	options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>,
+): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export function mutationOptions<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = void,
+	TOnMutateResult = unknown,
+>(
+	options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {
+	return options;
+}

package/src/queries-types.ts

@@ -0,0 +1,167 @@
+// The useQueries option/result tuple types — a 1:1 port of the type block in
+// @tanstack/react-query's useQueries.ts (pure query-core generics, no React).
+// `GetUseQueryOptionsForUseQueries` / `GetUseQueryResult` recursively unwrap
+// per-entry generics so tuple inputs infer per-index option/result types.
+import type { UseQueryOptions, UseQueryResult, DefinedUseQueryResult } from './types';
+import type {
+	DefaultError,
+	OmitKeyof,
+	QueriesPlaceholderDataFunction,
+	QueryFunction,
+	QueryKey,
+	ThrowOnError,
+} from '@tanstack/query-core';
+
+// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
+// `placeholderData` function always gets undefined passed
+type UseQueryOptionsForUseQueries<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+> = OmitKeyof<
+	UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+	'placeholderData' | 'subscribed'
+> & {
+	placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
+
+// Avoid TS depth-limit error in case of large array literal
+type MAXIMUM_DEPTH = 20;
+
+// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
+type SkipTokenForUseQueries = symbol;
+
+type GetUseQueryOptionsForUseQueries<T> =
+	// Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
+	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>
+				: // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, 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>
+							: // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
+								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
+									>
+								: // Fallback
+									UseQueryOptionsForUseQueries;
+
+// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult
+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> =
+	// Part 1: responsible for mapping explicit type parameter to function result, if object
+	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>
+				: // Part 2: responsible for mapping explicit type parameter to function result, if tuple
+					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>
+							: // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
+								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
+									>
+								: // Fallback
+									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
+					: // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
+						// use this to infer the param types in the case of Array.map() argument
+						T extends Array<
+								UseQueryOptionsForUseQueries<
+									infer TQueryFnData,
+									infer TError,
+									infer TData,
+									infer TQueryKey
+								>
+						  >
+						? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>>
+						: // Fallback
+							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]> };

package/src/queryOptions.ts

@@ -0,0 +1,83 @@
+// Verbatim port of @tanstack/react-query's queryOptions.ts — a typed identity helper
+import type {
+	DataTag,
+	DefaultError,
+	InitialDataFunction,
+	NonUndefinedGuard,
+	OmitKeyof,
+	QueryFunction,
+	QueryKey,
+	SkipToken,
+} from '@tanstack/query-core';
+import type { 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
+	>;
+};
+
+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 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 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 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 function queryOptions(options: unknown) {
+	return options;
+}

package/src/suspense-queries-types.ts

@@ -0,0 +1,141 @@
+// The useSuspenseQueries option/result tuple types — a 1:1 port of the type
+// block in @tanstack/react-query's useSuspenseQueries.ts (pure query-core
+// generics, no React).
+import type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types';
+import type { DefaultError, QueryFunction, ThrowOnError } from '@tanstack/query-core';
+
+// Avoid TS depth-limit error in case of large array literal
+type MAXIMUM_DEPTH = 20;
+
+// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
+type SkipTokenForUseQueries = symbol;
+
+type GetUseSuspenseQueryOptions<T> =
+	// Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
+	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>
+				: // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, 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>
+							: // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
+								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>
+									: // Fallback
+										UseSuspenseQueryOptions;
+
+type GetUseSuspenseQueryResult<T> =
+	// Part 1: responsible for mapping explicit type parameter to function result, if object
+	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>
+				: // Part 2: responsible for mapping explicit type parameter to function result, if tuple
+					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>
+							: // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
+								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
+										>
+									: // Fallback
+										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
+					: // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
+						// use this to infer the param types in the case of Array.map() argument
+						T extends Array<
+								UseSuspenseQueryOptions<
+									infer TQueryFnData,
+									infer TError,
+									infer TData,
+									infer TQueryKey
+								>
+						  >
+						? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>>
+						: // Fallback
+							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]> };

package/src/types.ts

@@ -0,0 +1,232 @@
+// The binding-level type surface — a 1:1 port of @tanstack/react-query's
+// types.ts (it is built entirely on query-core generics; nothing here is
+// React-specific), plus the component prop / context-value types at the bottom
+// (where upstream's React.ReactNode becomes octane's `unknown` renderable).
+import type {
+	DefaultError,
+	DefinedInfiniteQueryObserverResult,
+	DefinedQueryObserverResult,
+	DehydratedState,
+	DistributiveOmit,
+	FetchQueryOptions,
+	HydrateOptions,
+	InfiniteQueryObserverOptions,
+	InfiniteQueryObserverResult,
+	MutateFunction,
+	MutationObserverOptions,
+	MutationObserverResult,
+	OmitKeyof,
+	Override,
+	QueryClient,
+	QueryKey,
+	QueryObserverOptions,
+	QueryObserverResult,
+	SkipToken,
+} from '@tanstack/query-core';
+
+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 interface UsePrefetchQueryOptions<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+> extends OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> {
+	queryFn?: Exclude<
+		FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],
+		SkipToken
+	>;
+}
+
+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>;
+export interface UseInfiniteQueryOptions<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+	TPageParam = unknown,
+> extends OmitKeyof<
+	InfiniteQueryObserverOptions<TQueryFnData, TError, TData, 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
+>;
+export interface UseSuspenseInfiniteQueryOptions<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+	TPageParam = unknown,
+> extends OmitKeyof<
+	UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
+	'queryFn' | 'enabled' | 'throwOnError' | 'placeholderData'
+> {
+	queryFn?: Exclude<
+		UseInfiniteQueryOptions<TQueryFnData, TError, TData, 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,
+	TOnMutateResult = unknown,
+> extends OmitKeyof<
+	MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,
+	'_defaulted'
+> {}
+
+export type UseMutateFunction<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = void,
+	TOnMutateResult = unknown,
+> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+
+export type UseMutateAsyncFunction<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = void,
+	TOnMutateResult = unknown,
+> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+
+export type UseBaseMutationResult<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = unknown,
+	TOnMutateResult = unknown,
+> = Override<
+	MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,
+	{ mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }
+> & {
+	mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
+};
+
+export type UseMutationResult<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = unknown,
+	TOnMutateResult = unknown,
+> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
+
+// ---------------------------------------------------------------------------
+// Component prop + context-value types (octane: children are renderables, so
+// upstream's React.ReactNode becomes `unknown`; render-prop children are also
+// accepted where upstream accepts them).
+// ---------------------------------------------------------------------------
+
+export interface QueryClientProviderProps {
+	client: QueryClient;
+	children?: unknown;
+}
+
+export interface HydrationBoundaryProps {
+	state: DehydratedState | null | undefined;
+	options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
+		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
+	};
+	children?: unknown;
+	queryClient?: QueryClient;
+}
+
+export type QueryErrorResetFunction = () => void;
+export type QueryErrorIsResetFunction = () => boolean;
+export type QueryErrorClearResetFunction = () => void;
+
+export interface QueryErrorResetBoundaryValue {
+	clearReset: QueryErrorClearResetFunction;
+	isReset: QueryErrorIsResetFunction;
+	reset: QueryErrorResetFunction;
+}
+
+export type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => unknown;
+
+export interface QueryErrorResetBoundaryProps {
+	children: QueryErrorResetBoundaryFunction | unknown;
+}