@octanejs/apollo-client 0.1.0

package/src/react/hooks/useSuspenseQuery.js

@@ -0,0 +1,130 @@
+import * as React from 'octane';
+import { NetworkStatus } from '@apollo/client';
+import { getSuspenseCache } from '@octanejs/apollo-client/react/internal';
+import { __DEV__ } from '@apollo/client/utilities/environment';
+import { variablesUnknownSymbol } from '@apollo/client/utilities/internal';
+import { skipToken } from './constants.js';
+import { __use, useDeepMemo, useSuspenseHookCacheKey, wrapHook } from './internal/index.js';
+import { isCompilerSite } from './internal/site.js';
+import { validateSuspenseHookOptions } from './internal/validateSuspenseHookOptions.js';
+import { useApolloClient } from './useApolloClient.js';
+export const useSuspenseQuery = function useSuspenseQuery(query, options, site) {
+	'use no memo';
+	if (isCompilerSite(options, skipToken)) {
+		site = options;
+		options = undefined;
+	}
+	return wrapHook(
+		'useSuspenseQuery',
+		useSuspenseQuery_,
+		useApolloClient(typeof options === 'object' ? options.client : undefined),
+	)(query, options ?? {}, site);
+};
+function useSuspenseQuery_(query, options, site) {
+	const client = useApolloClient(options.client);
+	const suspenseCache = getSuspenseCache(client);
+	const watchQueryOptions = useWatchQueryOptions({
+		client,
+		query,
+		options,
+	});
+	const { fetchPolicy } = watchQueryOptions;
+	const cacheKey = useSuspenseHookCacheKey(query, options);
+	const queryRef = suspenseCache.getQueryRef(cacheKey, () => client.watchQuery(watchQueryOptions));
+	let [current, setPromise] = React.useState([queryRef.key, queryRef.promise]);
+	// This saves us a re-execution of the render function when a variable changed.
+	if (current[0] !== queryRef.key) {
+		// eslint-disable-next-line react-hooks/immutability
+		current[0] = queryRef.key;
+		// eslint-disable-next-line react-hooks/immutability
+		current[1] = queryRef.promise;
+	}
+	let promise = current[1];
+	if (queryRef.didChangeOptions(watchQueryOptions)) {
+		// eslint-disable-next-line react-hooks/immutability
+		current[1] = promise = queryRef.applyOptions(watchQueryOptions);
+	}
+	React.useEffect(() => {
+		const dispose = queryRef.retain();
+		const removeListener = queryRef.listen((promise) => {
+			setPromise([queryRef.key, promise]);
+		});
+		return () => {
+			removeListener();
+			dispose();
+		};
+	}, [queryRef]);
+	const skipResult = React.useMemo(() => {
+		const error = queryRef.result.error;
+		const complete = !!queryRef.result.data;
+		return {
+			loading: false,
+			data: queryRef.result.data,
+			dataState: queryRef.result.dataState,
+			networkStatus: error ? NetworkStatus.error : NetworkStatus.ready,
+			error,
+			complete,
+			partial: !complete,
+		};
+	}, [queryRef.result]);
+	const result = fetchPolicy === 'standby' ? skipResult : __use(promise, site);
+	const fetchMore = React.useCallback(
+		(options) => {
+			const promise = queryRef.fetchMore(options);
+			setPromise([queryRef.key, queryRef.promise]);
+			return promise;
+		},
+		[queryRef],
+	);
+	const refetch = React.useCallback(
+		(variables) => {
+			const promise = queryRef.refetch(variables);
+			setPromise([queryRef.key, queryRef.promise]);
+			return promise;
+		},
+		[queryRef],
+	);
+	// TODO: The internalQueryRef doesn't have TVariables' type information so we have to cast it here
+	const subscribeToMore = queryRef.observable.subscribeToMore;
+	return React.useMemo(() => {
+		return {
+			client,
+			data: result.data,
+			dataState: result.dataState,
+			error: result.error,
+			networkStatus: result.networkStatus,
+			fetchMore,
+			refetch,
+			subscribeToMore,
+		};
+	}, [client, fetchMore, refetch, result, subscribeToMore]);
+}
+export function useWatchQueryOptions({ client, query, options }) {
+	return useDeepMemo(() => {
+		if (options === skipToken) {
+			return {
+				query,
+				fetchPolicy: 'standby',
+				[variablesUnknownSymbol]: true,
+			};
+		}
+		const fetchPolicy =
+			options.fetchPolicy || client.defaultOptions.watchQuery?.fetchPolicy || 'cache-first';
+		const watchQueryOptions = {
+			...options,
+			fetchPolicy,
+			query,
+			notifyOnNetworkStatusChange: false,
+			nextFetchPolicy: void 0,
+		};
+		if (__DEV__) {
+			validateSuspenseHookOptions(watchQueryOptions);
+		}
+		// Assign the updated fetch policy after our validation since `standby` is
+		// not a supported fetch policy on its own without the use of `skip`.
+		if (options.skip) {
+			watchQueryOptions.fetchPolicy = 'standby';
+		}
+		return watchQueryOptions;
+	}, [client, options, query]);
+}

package/src/react/hooks/useSyncExternalStore.d.ts

@@ -0,0 +1,2 @@
+export declare const useSyncExternalStore: typeof import('octane').useSyncExternalStore;
+export {};

package/src/react/hooks/useSyncExternalStore.js

@@ -0,0 +1,125 @@
+import * as React from 'octane';
+import { __DEV__ } from '@apollo/client/utilities/environment';
+import { canUseDOM } from '@apollo/client/utilities/internal';
+import { maybe } from '@apollo/client/utilities/internal/globals';
+import { invariant } from '@apollo/client/utilities/invariant';
+let didWarnUncachedGetSnapshot = false;
+// Prevent webpack from complaining about our feature detection of the
+// useSyncExternalStore property of the React namespace, which is expected not
+// to exist when using React 17 and earlier, and that's fine.
+const uSESKey = 'useSyncExternalStore';
+const realHook = React[uSESKey];
+const isReactNative = maybe(() => navigator.product) == 'ReactNative';
+const usingJSDOM =
+	// Following advice found in this comment from @domenic (maintainer of jsdom):
+	// https://github.com/jsdom/jsdom/issues/1537#issuecomment-229405327
+	//
+	// Since we control the version of Jest and jsdom used when running Apollo
+	// Client tests, and that version is recent enough to include " jsdom/x.y.z"
+	// at the end of the user agent string, I believe this case is all we need to
+	// check. Testing for "Node.js" was recommended for backwards compatibility
+	// with older version of jsdom, but we don't have that problem.
+	maybe(() => navigator.userAgent.indexOf('jsdom') >= 0) || false;
+// Our tests should all continue to pass if we remove this !usingJSDOM
+// condition, thereby allowing useLayoutEffect when using jsdom. Unfortunately,
+// if we allow useLayoutEffect, then useSyncExternalStore generates many
+// warnings about useLayoutEffect doing nothing on the server. While these
+// warnings are harmless, this !usingJSDOM condition seems to be the best way to
+// prevent them (i.e. skipping useLayoutEffect when using jsdom).
+const canUseLayoutEffect = (canUseDOM || isReactNative) && !usingJSDOM;
+// Adapted from https://www.npmjs.com/package/use-sync-external-store, with
+// Apollo Client deviations called out by "// DEVIATION ..." comments.
+// When/if React.useSyncExternalStore is defined, delegate fully to it.
+export const useSyncExternalStore =
+	realHook ||
+	((subscribe, getSnapshot, getServerSnapshot) => {
+		// Read the current snapshot from the store on every render. Again, this
+		// breaks the rules of React, and only works here because of specific
+		// implementation details, most importantly that updates are
+		// always synchronous.
+		const value = getSnapshot();
+		if (
+			// DEVIATION: Using __DEV__
+			__DEV__ &&
+			!didWarnUncachedGetSnapshot &&
+			// DEVIATION: Not using Object.is because we know our snapshots will never
+			// be exotic primitive values like NaN, which is !== itself.
+			value !== getSnapshot()
+		) {
+			didWarnUncachedGetSnapshot = true;
+			// DEVIATION: Using invariant.error instead of console.error directly.
+			invariant.error(34);
+		}
+		// Because updates are synchronous, we don't queue them. Instead we force a
+		// re-render whenever the subscribed state changes by updating an some
+		// arbitrary useState hook. Then, during render, we call getSnapshot to read
+		// the current value.
+		//
+		// Because we don't actually use the state returned by the useState hook, we
+		// can save a bit of memory by storing other stuff in that slot.
+		//
+		// To implement the early bailout, we need to track some things on a mutable
+		// object. Usually, we would put that in a useRef hook, but we can stash it in
+		// our useState hook instead.
+		//
+		// To force a re-render, we call forceUpdate({inst}). That works because the
+		// new object always fails an equality check.
+		const [{ inst }, forceUpdate] = React.useState({
+			inst: { value, getSnapshot },
+		});
+		// Track the latest getSnapshot function with a ref. This needs to be updated
+		// in the layout phase so we can access it during the tearing check that
+		// happens on subscribe.
+		if (canUseLayoutEffect) {
+			// DEVIATION: We avoid calling useLayoutEffect when !canUseLayoutEffect,
+			// which may seem like a conditional hook, but this code ends up behaving
+			// unconditionally (one way or the other) because canUseLayoutEffect is
+			// constant.
+			React.useLayoutEffect(() => {
+				Object.assign(inst, { value, getSnapshot });
+				// Whenever getSnapshot or subscribe changes, we need to check in the
+				// commit phase if there was an interleaved mutation. In concurrent mode
+				// this can happen all the time, but even in synchronous mode, an earlier
+				// effect may have mutated the store.
+				if (checkIfSnapshotChanged(inst)) {
+					// Force a re-render.
+					forceUpdate({ inst });
+				}
+				// React Hook React.useLayoutEffect has a missing dependency: 'inst'. Either include it or remove the dependency array.
+				// eslint-disable-next-line react-hooks/exhaustive-deps
+			}, [subscribe, value, getSnapshot]);
+		} else {
+			Object.assign(inst, { value, getSnapshot });
+		}
+		React.useEffect(() => {
+			// Check for changes right before subscribing. Subsequent changes will be
+			// detected in the subscription handler.
+			if (checkIfSnapshotChanged(inst)) {
+				// Force a re-render.
+				forceUpdate({ inst });
+			}
+			// Subscribe to the store and return a clean-up function.
+			return subscribe(function handleStoreChange() {
+				// TODO: Because there is no cross-renderer API for batching updates, it's
+				// up to the consumer of this library to wrap their subscription event
+				// with unstable_batchedUpdates. Should we try to detect when this isn't
+				// the case and print a warning in development?
+				// The store changed. Check if the snapshot changed since the last time we
+				// read from the store.
+				if (checkIfSnapshotChanged(inst)) {
+					// Force a re-render.
+					forceUpdate({ inst });
+				}
+			});
+			// React Hook React.useEffect has a missing dependency: 'inst'. Either include it or remove the dependency array.
+			// eslint-disable-next-line react-hooks/exhaustive-deps
+		}, [subscribe]);
+		return value;
+	});
+function checkIfSnapshotChanged({ value, getSnapshot }) {
+	try {
+		return value !== getSnapshot();
+	} catch {
+		return true;
+	}
+}

package/src/react/index.d.ts

@@ -0,0 +1,68 @@
+export type { ApolloContextValue } from './context/ApolloContext.js';
+export { getApolloContext } from './context/ApolloContext.js';
+export { ApolloProvider } from './context/ApolloProvider.js';
+export { useApolloClient } from './hooks/useApolloClient.js';
+export { useLazyQuery } from './hooks/useLazyQuery.js';
+export { useMutation } from './hooks/useMutation.js';
+export { useQuery } from './hooks/useQuery.js';
+export { useSubscription } from './hooks/useSubscription.js';
+export { useReactiveVar } from './hooks/useReactiveVar.js';
+export { useFragment } from './hooks/useFragment.js';
+export { useSuspenseQuery } from './hooks/useSuspenseQuery.js';
+export { useBackgroundQuery } from './hooks/useBackgroundQuery.js';
+export { useSuspenseFragment } from './hooks/useSuspenseFragment.js';
+export { useLoadableQuery } from './hooks/useLoadableQuery.js';
+export { useQueryRefHandlers } from './hooks/useQueryRefHandlers.js';
+export { useReadQuery } from './hooks/useReadQuery.js';
+export { skipToken } from './hooks/constants.js';
+export type { SkipToken } from './hooks/constants.js';
+export type {
+	PreloadQueryFetchPolicy,
+	PreloadQueryFunction,
+	PreloadQueryOptions,
+} from './query-preloader/createQueryPreloader.js';
+export { createQueryPreloader } from './query-preloader/createQueryPreloader.js';
+export type { PreloadedQueryRef, QueryRef } from '@octanejs/apollo-client/react/internal';
+export type {
+	BackgroundQueryHookFetchPolicy,
+	BackgroundQueryHookOptions,
+	LazyQueryExecFunction,
+	LazyQueryHookExecOptions,
+	LazyQueryHookOptions,
+	LazyQueryResult,
+	LazyQueryResultTuple,
+	LoadableQueryFetchPolicy,
+	LoadableQueryHookOptions,
+	LoadQueryFunction,
+	MutationFunctionOptions,
+	MutationHookOptions,
+	MutationResult,
+	MutationTuple,
+	OnDataOptions,
+	OnSubscriptionDataOptions,
+	QueryHookOptions,
+	QueryResult,
+	SubscriptionHookOptions,
+	SubscriptionResult,
+	SuspenseQueryHookFetchPolicy,
+	SuspenseQueryHookOptions,
+	UseBackgroundQueryResult,
+	UseFragmentOptions,
+	UseFragmentResult,
+	UseLoadableQueryResult,
+	UseQueryRefHandlersResult,
+	UseReadQueryResult,
+	UseSuspenseFragmentOptions,
+	UseSuspenseFragmentResult,
+	UseSuspenseQueryResult,
+} from './types/deprecated.js';
+import type { HookWrappers } from './hooks/internal/wrapHook.js';
+/**
+ * @internal
+ *
+ * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+ */
+export declare namespace InternalTypes {
+	export type { HookWrappers };
+}
+export declare const reactCompilerVersion: string;

package/src/react/index.js

@@ -0,0 +1,18 @@
+export { getApolloContext } from './context/ApolloContext.js';
+export { ApolloProvider } from './context/ApolloProvider.js';
+export { useApolloClient } from './hooks/useApolloClient.js';
+export { useLazyQuery } from './hooks/useLazyQuery.js';
+export { useMutation } from './hooks/useMutation.js';
+export { useQuery } from './hooks/useQuery.js';
+export { useSubscription } from './hooks/useSubscription.js';
+export { useReactiveVar } from './hooks/useReactiveVar.js';
+export { useFragment } from './hooks/useFragment.js';
+export { useSuspenseQuery } from './hooks/useSuspenseQuery.js';
+export { useBackgroundQuery } from './hooks/useBackgroundQuery.js';
+export { useSuspenseFragment } from './hooks/useSuspenseFragment.js';
+export { useLoadableQuery } from './hooks/useLoadableQuery.js';
+export { useQueryRefHandlers } from './hooks/useQueryRefHandlers.js';
+export { useReadQuery } from './hooks/useReadQuery.js';
+export { skipToken } from './hooks/constants.js';
+export { createQueryPreloader } from './query-preloader/createQueryPreloader.js';
+export const reactCompilerVersion = 'uncompiled';

package/src/react/internal/cache/FragmentReference.d.ts

@@ -0,0 +1,41 @@
+import type { ApolloClient, OperationVariables } from '@apollo/client';
+import type { MaybeMasked } from '@apollo/client/masking';
+import type { DecoratedPromise } from '@apollo/client/utilities/internal';
+import type { FragmentKey } from './types.js';
+type FragmentRefPromise<TData> = DecoratedPromise<TData>;
+type Listener<TData> = (promise: FragmentRefPromise<TData>) => void;
+interface FragmentReferenceOptions {
+	autoDisposeTimeoutMs?: number;
+	onDispose?: () => void;
+}
+export declare class FragmentReference<
+	TData = unknown,
+	TVariables extends OperationVariables = OperationVariables,
+> {
+	readonly observable: ApolloClient.ObservableFragment<TData | null>;
+	readonly key: FragmentKey;
+	promise: FragmentRefPromise<MaybeMasked<TData>>;
+	private resolve;
+	private reject;
+	private subscription;
+	private listeners;
+	private autoDisposeTimeoutId?;
+	private references;
+	constructor(
+		client: ApolloClient,
+		watchFragmentOptions: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+			from: string | null | Array<string | null>;
+		},
+		options: FragmentReferenceOptions,
+	);
+	listen(listener: Listener<MaybeMasked<TData>>): () => void;
+	retain(): () => void;
+	private dispose;
+	private onDispose;
+	private subscribeToFragment;
+	private handleNext;
+	private handleError;
+	private deliver;
+	private createPendingPromise;
+}
+export {};

package/src/react/internal/cache/FragmentReference.js

@@ -0,0 +1,117 @@
+import { equal } from '@wry/equality';
+import { createFulfilledPromise, decoratePromise } from '@apollo/client/utilities/internal';
+export class FragmentReference {
+	observable;
+	key = {};
+	promise;
+	resolve;
+	reject;
+	subscription;
+	listeners = new Set();
+	autoDisposeTimeoutId;
+	references = 0;
+	constructor(client, watchFragmentOptions, options) {
+		this.dispose = this.dispose.bind(this);
+		this.handleNext = this.handleNext.bind(this);
+		this.handleError = this.handleError.bind(this);
+		this.observable = client.watchFragment(watchFragmentOptions);
+		if (options.onDispose) {
+			this.onDispose = options.onDispose;
+		}
+		const result = this.observable.getCurrentResult();
+		// Start a timer that will automatically dispose of the query if the
+		// suspended resource does not use this fragmentRef in the given time. This
+		// helps prevent memory leaks when a component has unmounted before the
+		// query has finished loading.
+		const startDisposeTimer = () => {
+			if (!this.references) {
+				this.autoDisposeTimeoutId = setTimeout(
+					this.dispose,
+					options.autoDisposeTimeoutMs ?? 30_000,
+				);
+			}
+		};
+		this.promise = result.complete
+			? createFulfilledPromise(result.data)
+			: this.createPendingPromise();
+		this.subscribeToFragment();
+		this.promise.then(startDisposeTimer, startDisposeTimer);
+	}
+	listen(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	retain() {
+		this.references++;
+		clearTimeout(this.autoDisposeTimeoutId);
+		let disposed = false;
+		return () => {
+			if (disposed) {
+				return;
+			}
+			disposed = true;
+			this.references--;
+			setTimeout(() => {
+				if (!this.references) {
+					this.dispose();
+				}
+			});
+		};
+	}
+	dispose() {
+		this.subscription.unsubscribe();
+	}
+	onDispose() {
+		// noop. overridable by options
+	}
+	subscribeToFragment() {
+		this.subscription = this.observable.subscribe(
+			this.handleNext.bind(this),
+			this.handleError.bind(this),
+		);
+		// call `onDispose` when the subscription is finalized, either because it is
+		// unsubscribed as a consequence of a `dispose` call or because the
+		// ObservableQuery completes because of a `ApolloClient.stop()` call.
+		this.subscription.add(this.onDispose);
+	}
+	handleNext(result) {
+		switch (this.promise.status) {
+			case 'pending': {
+				if (result.complete) {
+					return this.resolve?.(result.data);
+				}
+				this.deliver(this.promise);
+				break;
+			}
+			case 'fulfilled': {
+				// This can occur when we already have a result written to the cache and
+				// we subscribe for the first time. We create a fulfilled promise in the
+				// constructor with a value that is the same as the first emitted value
+				// so we want to skip delivering it.
+				if (equal(this.promise.value, result.data)) {
+					return;
+				}
+				this.promise = result.complete
+					? createFulfilledPromise(result.data)
+					: this.createPendingPromise();
+				this.deliver(this.promise);
+			}
+		}
+	}
+	handleError(error) {
+		this.reject?.(error);
+	}
+	deliver(promise) {
+		this.listeners.forEach((listener) => listener(promise));
+	}
+	createPendingPromise() {
+		return decoratePromise(
+			new Promise((resolve, reject) => {
+				this.resolve = resolve;
+				this.reject = reject;
+			}),
+		);
+	}
+}

package/src/react/internal/cache/QueryReference.d.ts

@@ -0,0 +1,180 @@
+import type {
+	DocumentTypeDecoration,
+	ResultOf,
+	VariablesOf,
+} from '@graphql-typed-document-node/core';
+import type { ApolloClient, DataState, ObservableQuery, OperationVariables } from '@apollo/client';
+import type { MaybeMasked } from '@apollo/client/masking';
+import type { DecoratedPromise } from '@apollo/client/utilities/internal';
+import type { QueryKey } from './types.js';
+type QueryRefPromise<TData, TStates extends DataState<TData>['dataState']> = DecoratedPromise<
+	ObservableQuery.Result<MaybeMasked<TData>, TStates>
+>;
+type Listener<TData, TStates extends DataState<TData>['dataState']> = (
+	promise: QueryRefPromise<TData, TStates>,
+) => void;
+declare const QUERY_REFERENCE_SYMBOL: unique symbol;
+declare const PROMISE_SYMBOL: unique symbol;
+declare const QUERY_REF_BRAND: unique symbol;
+declare const PRELOADED_QUERY_REF_BRAND: unique symbol;
+/**
+ * A `QueryReference` is an opaque object returned by `useBackgroundQuery`.
+ * A child component reading the `QueryReference` via `useReadQuery` will
+ * suspend until the promise resolves.
+ */
+export interface QueryRef<
+	TData = unknown,
+	TVariables extends OperationVariables = OperationVariables,
+	TStates extends DataState<TData>['dataState'] = 'complete' | 'streaming',
+> {
+	/**
+	 * @internal
+	 *
+	 * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+	 */
+	[QUERY_REF_BRAND]?(variables: TVariables): {
+		data: TData;
+		states: TStates;
+	};
+}
+export declare namespace QueryRef {
+	type ForQuery<
+		Document extends DocumentTypeDecoration<any, any>,
+		TStates extends DataState<ResultOf<Document>>['dataState'] = 'complete' | 'streaming',
+	> = QueryRef<ResultOf<Document>, VariablesOf<Document>, TStates>;
+}
+/**
+ * @internal
+ * For usage in internal helpers only.
+ *
+ * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+ */
+interface WrappedQueryRef<
+	TData = unknown,
+	TVariables extends OperationVariables = OperationVariables,
+	TStates extends DataState<TData>['dataState'] = 'complete' | 'streaming',
+> extends QueryRef<TData, TVariables, TStates> {
+	/**
+	 * @internal
+	 *
+	 * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+	 */
+	readonly [QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData, TStates>;
+	/**
+	 * @internal
+	 *
+	 * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+	 */
+	[PROMISE_SYMBOL]: QueryRefPromise<TData, TStates>;
+}
+/**
+ * A `QueryReference` is an opaque object returned by `useBackgroundQuery`.
+ * A child component reading the `QueryReference` via `useReadQuery` will
+ * suspend until the promise resolves.
+ */
+export interface PreloadedQueryRef<
+	TData = unknown,
+	TVariables extends OperationVariables = OperationVariables,
+	TStates extends DataState<TData>['dataState'] = 'complete' | 'streaming',
+> extends QueryRef<TData, TVariables, TStates> {
+	/**
+	 * @internal
+	 *
+	 * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+	 */
+	[PRELOADED_QUERY_REF_BRAND]: typeof PRELOADED_QUERY_REF_BRAND;
+}
+interface InternalQueryReferenceOptions {
+	onDispose?: () => void;
+	autoDisposeTimeoutMs?: number;
+}
+export declare function wrapQueryRef<
+	TData,
+	TVariables extends OperationVariables,
+	TStates extends DataState<TData>['dataState'],
+>(
+	internalQueryRef: InternalQueryReference<TData, TStates>,
+): WrappedQueryRef<TData, TVariables, TStates>;
+export declare function assertWrappedQueryRef<
+	TData,
+	TVariables extends OperationVariables,
+	TStates extends DataState<TData>['dataState'],
+>(
+	queryRef: QueryRef<TData, TVariables, TStates>,
+): asserts queryRef is WrappedQueryRef<TData, TVariables, TStates>;
+export declare function assertWrappedQueryRef<
+	TData,
+	TVariables extends OperationVariables,
+	TStates extends DataState<TData>['dataState'],
+>(
+	queryRef: QueryRef<TData, TVariables, TStates> | undefined | null,
+): asserts queryRef is WrappedQueryRef<TData, TVariables, TStates> | undefined | null;
+export declare function getWrappedPromise<TData, TStates extends DataState<TData>['dataState']>(
+	queryRef: WrappedQueryRef<TData, any, TStates>,
+): QueryRefPromise<TData, TStates>;
+export declare function unwrapQueryRef<TData, TStates extends DataState<TData>['dataState']>(
+	queryRef: WrappedQueryRef<TData, any, TStates>,
+): InternalQueryReference<TData, TStates>;
+export declare function unwrapQueryRef<TData, TStates extends DataState<TData>['dataState']>(
+	queryRef: Partial<WrappedQueryRef<TData, any, TStates>>,
+): undefined | InternalQueryReference<TData, TStates>;
+export declare function updateWrappedQueryRef<TData, TStates extends DataState<TData>['dataState']>(
+	queryRef: WrappedQueryRef<TData, any, TStates>,
+	promise: QueryRefPromise<TData, TStates>,
+): void;
+declare const OBSERVED_CHANGED_OPTIONS: readonly [
+	'context',
+	'errorPolicy',
+	'fetchPolicy',
+	'refetchOn',
+	'refetchWritePolicy',
+	'returnPartialData',
+];
+type ObservedOptions = Pick<
+	ApolloClient.WatchQueryOptions,
+	(typeof OBSERVED_CHANGED_OPTIONS)[number]
+>;
+export declare class InternalQueryReference<
+	TData = unknown,
+	TStates extends DataState<TData>['dataState'] = DataState<TData>['dataState'],
+> {
+	result: ObservableQuery.Result<MaybeMasked<TData>, TStates>;
+	readonly key: QueryKey;
+	readonly observable: ObservableQuery<TData>;
+	promise: QueryRefPromise<TData, TStates>;
+	private queue;
+	private subscription;
+	private listeners;
+	private autoDisposeTimeoutId?;
+	private resolve;
+	private reject;
+	private references;
+	private softReferences;
+	constructor(observable: ObservableQuery<TData, any>, options: InternalQueryReferenceOptions);
+	get disposed(): boolean;
+	get watchQueryOptions(): ObservableQuery.Options<TData, OperationVariables>;
+	reinitialize(): void;
+	retain(): () => void;
+	softRetain(): () => void;
+	didChangeOptions(watchQueryOptions: ObservedOptions): boolean;
+	applyOptions(watchQueryOptions: ObservedOptions): QueryRefPromise<TData, TStates>;
+	listen(listener: Listener<TData, TStates>): () => void;
+	refetch(variables: OperationVariables | undefined): Promise<{
+		data: TData | undefined;
+		error?: import('@apollo/client').ErrorLike;
+	}>;
+	fetchMore(options: ObservableQuery.FetchMoreOptions<TData, any, any, any>): Promise<{
+		data: TData | undefined;
+		error?: import('@apollo/client').ErrorLike;
+	}>;
+	private dispose;
+	private onDispose;
+	private handleNext;
+	private deliver;
+	private initiateFetch;
+	private subscribeToQuery;
+	private setResult;
+	private shouldReject;
+	private createPendingPromise;
+}
+export {};