react-relay 20.1.1 → 21.0.1

package/relay-hooks/EntryPointTypes.flow.js.flow

@@ -34,20 +34,21 @@ export type PreloadFetchPolicy =
   | 'network-only';
 
 export type PreloadOptions = {
-  +fetchKey?: string | number,
-  +fetchPolicy?: ?PreloadFetchPolicy,
-  +includeIf?: ?boolean,
-  +prefetchExpiryInHours?: ?number,
-  +networkCacheConfig?: ?CacheConfig,
+  readonly fetchKey?: string | number,
+  readonly fetchPolicy?: ?PreloadFetchPolicy,
+  readonly includeIf?: ?boolean,
+  readonly enableForOfflineCacheJob?: ?boolean,
+  readonly prefetchExpiryInHours?: ?number,
+  readonly networkCacheConfig?: ?CacheConfig,
 };
 
 export type LoadQueryOptions = {
-  +fetchPolicy?: ?FetchPolicy,
-  +networkCacheConfig?: ?CacheConfig,
-  +__nameForWarning?: ?string,
+  readonly fetchPolicy?: ?FetchPolicy,
+  readonly networkCacheConfig?: ?CacheConfig,
+  readonly __nameForWarning?: ?string,
 };
 
-export type PreloadableConcreteRequest<+TQuery: OperationType> = {
+export type PreloadableConcreteRequest<out TQuery extends OperationType> = {
   kind: 'PreloadableConcreteRequest',
   params: RequestParameters,
   // Note: the phantom type parameter here helps ensures that the
@@ -55,63 +56,63 @@ export type PreloadableConcreteRequest<+TQuery: OperationType> = {
   // We also need to add usage of this generic here,
   // becuase not using the generic in the definition makes it
   // unconstrained in the call to a function that accepts PreloadableConcreteRequest<T>
-  +__phantom__?: ?TQuery,
+  readonly __phantom__?: ?TQuery,
 };
 
-export type EnvironmentProviderOptions = {+[string]: mixed, ...};
+export type EnvironmentProviderOptions = {readonly [string]: unknown, ...};
 
 export type PreloadedQuery<
-  +TQuery: OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
 > =
   | PreloadedQueryInner_DEPRECATED<TQuery, TEnvironmentProviderOptions>
   | PreloadedQueryInner<TQuery, TEnvironmentProviderOptions>;
 
 export type PreloadedQueryInner_DEPRECATED<
-  +TQuery: OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
 > = {
-  +kind: 'PreloadedQuery_DEPRECATED',
-  +environment: IEnvironment,
-  +environmentProviderOptions: ?TEnvironmentProviderOptions,
-  +fetchKey: ?string | ?number,
-  +fetchPolicy: FetchPolicy,
-  +networkCacheConfig?: ?CacheConfig,
-  +id: ?string,
-  +name: string,
-  +source: ?Observable<GraphQLResponse>,
-  +variables: TQuery['variables'],
-  +status: PreloadQueryStatus,
+  readonly kind: 'PreloadedQuery_DEPRECATED',
+  readonly environment: IEnvironment,
+  readonly environmentProviderOptions: ?TEnvironmentProviderOptions,
+  readonly fetchKey: ?string | ?number,
+  readonly fetchPolicy: FetchPolicy,
+  readonly networkCacheConfig?: ?CacheConfig,
+  readonly id: ?string,
+  readonly name: string,
+  readonly source: ?Observable<GraphQLResponse>,
+  readonly variables: TQuery['variables'],
+  readonly status: PreloadQueryStatus,
 };
 
 export type PreloadedQueryInner<
-  +TQuery: OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
 > = {
   // Releases query data and cancels network request if still in flight
-  +dispose: () => void,
+  readonly dispose: () => void,
   // Releases query data
-  +releaseQuery: () => void,
+  readonly releaseQuery: () => void,
   // Cancels network request if still in flight
-  +cancelNetworkRequest: () => void,
-  +environment: IEnvironment,
-  +environmentProviderOptions: ?TEnvironmentProviderOptions,
-  +fetchKey: string | number,
-  +fetchPolicy: FetchPolicy,
-  +id: ?string,
-  +isDisposed: boolean,
-  +networkError: ?Error,
-  +name: string,
-  +networkCacheConfig: ?CacheConfig,
-  +source: ?Observable<GraphQLResponse>,
-  +kind: 'PreloadedQuery',
-  +variables: TQuery['variables'],
+  readonly cancelNetworkRequest: () => void,
+  readonly environment: IEnvironment,
+  readonly environmentProviderOptions: ?TEnvironmentProviderOptions,
+  readonly fetchKey: string | number,
+  readonly fetchPolicy: FetchPolicy,
+  readonly id: ?string,
+  readonly isDisposed: boolean,
+  readonly networkError: ?Error,
+  readonly name: string,
+  readonly networkCacheConfig: ?CacheConfig,
+  readonly source: ?Observable<GraphQLResponse>,
+  readonly kind: 'PreloadedQuery',
+  readonly variables: TQuery['variables'],
 };
 
 export type PreloadQueryStatus = {
-  +cacheConfig: ?CacheConfig,
-  +source: 'cache' | 'network',
-  +fetchTime: ?number,
+  readonly cacheConfig: ?CacheConfig,
+  readonly source: 'cache' | 'network',
+  readonly fetchTime: ?number,
 };
 
 /**
@@ -125,40 +126,21 @@ Every .entrypoint file it's an object that must have two required fields:
 TEntryPointParams - object that contains all necessary information to execute
 the preloaders (routeParams, query variables)
 
-TPreloadedQueries -  queries, defined in the root components
-
-TPreloadedEntryPoints - nested entry points, defined in the root components
-
-TRuntimeProps - the type of additional props that you may pass to the
-component (like `onClick` handler, etc) during runtime. Values for them
-defined during component runtime
-
-TExtraProps - a bag of extra props that you may define in `entrypoint` file
-and they will be passed to the EntryPointComponent as `extraProps`
+TEntryPointComponent -  the root components
 */
-export type InternalEntryPointRepresentation<
-  TEntryPointParams,
-  TPreloadedQueries,
-  TPreloadedEntryPoints = {...},
-  TRuntimeProps = {...},
-  TExtraProps = null,
-> = $ReadOnly<{
+export type EntryPoint<
+  in TEntryPointParams,
+  // $FlowExpectedError[unclear-type] accepts any root component
+  out TEntryPointComponent extends EntryPointComponent<any, any, any, any, any>,
+> = Readonly<{
   getPreloadProps: (
     entryPointParams: TEntryPointParams,
   ) => PreloadProps<
-    TEntryPointParams,
-    TPreloadedQueries,
-    TPreloadedEntryPoints,
-    TExtraProps,
-  >,
-  root: JSResourceReference<
-    EntryPointComponent<
-      TPreloadedQueries,
-      TPreloadedEntryPoints,
-      TRuntimeProps,
-      TExtraProps,
-    >,
+    ElementConfig<TEntryPointComponent>['queries'],
+    ElementConfig<TEntryPointComponent>['entryPoints'],
+    ElementConfig<TEntryPointComponent>['extraProps'],
   >,
+  root: JSResourceReference<TEntryPointComponent>,
 }>;
 
 // The shape of the props of the entry point `root` component
@@ -167,20 +149,36 @@ export type EntryPointProps<
   TPreloadedEntryPoints = {},
   TRuntimeProps = {},
   TExtraProps = null,
-> = $ReadOnly<{
+> = Readonly<{
   entryPoints: TPreloadedEntryPoints,
   extraProps: TExtraProps | null,
   props: TRuntimeProps,
   queries: TPreloadedQueries,
 }>;
 
-// Type of the entry point `root` component
+/**
+Type of the entry point `root` component
+
+TEntryPointParams - object that contains all necessary information to execute
+the preloaders (routeParams, query variables)
+
+TPreloadedQueries -  queries, defined in the root components
+
+TPreloadedEntryPoints - nested entry points, defined in the root components
+
+TRuntimeProps - the type of additional props that you may pass to the
+component (like `onClick` handler, etc) during runtime. Values for them
+defined during component runtime
+
+TExtraProps - a bag of extra props that you may define in `entrypoint` file
+and they will be passed to the EntryPointComponent as `extraProps`
+*/
 export type EntryPointComponent<
   TPreloadedQueries,
   TPreloadedEntryPoints = {},
   TRuntimeProps = {},
   TExtraProps = null,
-  TRenders: React.Node = React.Node,
+  out TRenders extends React.Node = React.Node,
 > = component(
   ...EntryPointProps<
     TPreloadedQueries,
@@ -192,13 +190,12 @@ export type EntryPointComponent<
 
 // Return type of the `getPreloadProps(...)` of the entry point
 export type PreloadProps<
-  +TPreloadParams,
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries: {+[string]: PreloadedQuery<any>},
-  TPreloadedEntryPoints: {...},
+  TPreloadedQueries extends {readonly [string]: ?PreloadedQuery<any>},
+  TPreloadedEntryPoints extends {...},
   TExtraProps = null,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
-> = $ReadOnly<{
+> = Readonly<{
   entryPoints?: {
     +[K in keyof TPreloadedEntryPoints]?: ?ThinNestedEntryPointParams,
   },
@@ -207,7 +204,7 @@ export type PreloadProps<
 }>;
 
 // Return type of `loadEntryPoint(...)`
-export type PreloadedEntryPoint<TEntryPointComponent> = $ReadOnly<{
+export type PreloadedEntryPoint<TEntryPointComponent> = Readonly<{
   dispose: () => void,
   entryPoints: ElementConfig<TEntryPointComponent>['entryPoints'],
   extraProps: ElementConfig<TEntryPointComponent>['extraProps'],
@@ -218,27 +215,24 @@ export type PreloadedEntryPoint<TEntryPointComponent> = $ReadOnly<{
 }>;
 
 export type EntryPointElementConfig<
-  // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
-  +TEntryPoint: InternalEntryPointRepresentation<any, any, any, any, any>,
-> =
-  TEntryPoint extends InternalEntryPointRepresentation<
-    // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
-    any,
+  out TEntryPoint extends EntryPoint<
     // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
     any,
     // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
     any,
-    infer Props,
-    // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
-    any,
+  >,
+> =
+  TEntryPoint extends EntryPoint<
+    infer _EntryPointParams,
+    infer EntryPointComponent,
   >
-    ? Props
+    ? ElementConfig<EntryPointComponent>['props']
     : empty;
 
 export type ThinQueryParams<
-  +TQuery: OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions,
-> = $ReadOnly<{
+> = Readonly<{
   environmentProviderOptions?: ?TEnvironmentProviderOptions,
   options?: ?PreloadOptions,
   parameters: PreloadableConcreteRequest<TQuery>,
@@ -260,21 +254,29 @@ export type ExtractQueryTypeHelper<TEnvironmentProviderOptions> = <TQuery>(
 // We need to match both cases without using distributive conditional types,
 // because PreloadedQuery's TQuery parameter is almost phantom, and breaking
 // up the union type would cause us to lose track of TQuery.
-type ExtractThinQueryParams<T, TEnvironmentProviderOptions> = [+t: T] extends [
-  // $FlowFixMe[incompatible-type-arg]
-  +t: PreloadedQuery<infer TQuery>,
+type ExtractThinQueryParams<T, TEnvironmentProviderOptions> = [
+  readonly t: T,
+] extends [
+  // $FlowFixMe[incompatible-type]
+  readonly t: PreloadedQuery<infer TQuery extends OperationType>,
 ]
   ? ThinQueryParams<TQuery, TEnvironmentProviderOptions>
-  : [+t: T] extends [
-        +t: PreloadedQuery<infer TQuery extends OperationType> | void,
+  : [readonly t: T] extends [
+        readonly t: PreloadedQuery<infer TQuery extends OperationType> | void,
       ]
     ? ThinQueryParams<TQuery, TEnvironmentProviderOptions> | void
-    : empty;
+    : [readonly t: T] extends [
+          readonly t: PreloadedQuery<
+            infer TQuery extends OperationType,
+          > | null | void,
+        ]
+      ? ThinQueryParams<TQuery, TEnvironmentProviderOptions> | null | void
+      : empty;
 
 export type ExtractQueryTypes<
   TEnvironmentProviderOptions,
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  PreloadedQueries: {+[string]: PreloadedQuery<any>} | void,
+  PreloadedQueries extends {readonly [string]: ?PreloadedQuery<any>} | void,
 > = {
   [K in keyof PreloadedQueries]: ExtractThinQueryParams<
     PreloadedQueries[K],
@@ -282,17 +284,13 @@ export type ExtractQueryTypes<
   >,
 };
 
-export type EntryPoint<TEntryPointParams, +TEntryPointComponent> =
-  InternalEntryPointRepresentation<
-    TEntryPointParams,
-    ElementConfig<TEntryPointComponent>['queries'],
-    ElementConfig<TEntryPointComponent>['entryPoints'],
-    ElementConfig<TEntryPointComponent>['props'],
-    ElementConfig<TEntryPointComponent>['extraProps'],
-  >;
+// $FlowFixMe[unclear-type]: we don't care about the props
+export type RootComponentRenders<out C extends component(...any)> =
+  // $FlowFixMe[unclear-type]: we don't care about the props
+  C extends component(...any) renders infer R extends React.Node ? R : empty;
 
 export type PreloadParamsOf<T> = Parameters<T['getPreloadProps']>[0];
 
-export type IEnvironmentProvider<TOptions> = $ReadOnly<{
+export type IEnvironmentProvider<TOptions> = Readonly<{
   getEnvironment: (options: ?TOptions) => IEnvironment,
 }>;

package/relay-hooks/LazyLoadEntryPointContainer_DEPRECATED.react.js.flow

@@ -26,7 +26,7 @@ const React = require('react');
 const {useContext, useEffect, useMemo} = require('react');
 const {stableCopy} = require('relay-runtime');
 
-type PreloadedEntryPoint<TEntryPointComponent> = $ReadOnly<{
+type PreloadedEntryPoint<TEntryPointComponent> = Readonly<{
   entryPoints: React.ElementConfig<TEntryPointComponent>['entryPoints'],
   extraProps: React.ElementConfig<TEntryPointComponent>['extraProps'],
   getComponent: () => TEntryPointComponent,
@@ -40,8 +40,8 @@ type EntryPointContainerProps<
   TPreloadedEntryPoints,
   TRuntimeProps,
   TExtraProps,
-> = $ReadOnly<
-  $ReadOnly<{
+> = Readonly<
+  Readonly<{
     entryPoint: EntryPoint<
       TEntryPointParams,
       EntryPointComponent<
@@ -57,24 +57,24 @@ type EntryPointContainerProps<
   }>,
 >;
 
-function stableStringify(value: mixed): string {
+function stableStringify(value: unknown): string {
   return JSON.stringify(stableCopy(value)) ?? 'null';
 }
 
 function prepareEntryPoint<
-  TEntryPointParams: {...},
+  TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries: {+[string]: PreloadedQuery<any>},
-  TPreloadedEntryPoints: {...},
-  TRuntimeProps: {...},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
+  TPreloadedEntryPoints extends {...},
+  TRuntimeProps extends {...},
   TExtraProps,
-  TEntryPointComponent: EntryPointComponent<
+  TEntryPointComponent extends EntryPointComponent<
     TPreloadedQueries,
     TPreloadedEntryPoints,
     TRuntimeProps,
     TExtraProps,
   >,
-  TEntryPoint: EntryPoint<TEntryPointParams, TEntryPointComponent>,
+  TEntryPoint extends EntryPoint<TEntryPointParams, TEntryPointComponent>,
 >(
   environmentProvider: IEnvironmentProvider<EnvironmentProviderOptions>,
   entryPoint: TEntryPoint,
@@ -104,7 +104,7 @@ function prepareEntryPoint<
       // $FlowFixMe[incompatible-type]
       preloadedQueries[queryPropName] = preloadQuery_DEPRECATED<
         OperationType,
-        mixed,
+        unknown,
       >(
         environment,
         parameters,
@@ -129,14 +129,15 @@ function prepareEntryPoint<
         {},
         {...},
         {...},
-        mixed,
-        EntryPointComponent<{}, {...}, {...}, mixed>,
+        unknown,
+        EntryPointComponent<{}, {...}, {...}, unknown>,
         _,
       >(environmentProvider, nestedEntryPoint, nestedParams);
     });
   }
   return {
-    entryPoints: (preloadedEntryPoints: TPreloadedEntryPoints),
+    // $FlowFixMe[incompatible-type]
+    entryPoints: preloadedEntryPoints as TPreloadedEntryPoints,
     extraProps: extraProps ?? null,
     getComponent: () => {
       const component = entryPoint.root.getModuleIfRequired();
@@ -144,20 +145,21 @@ function prepareEntryPoint<
         loadingPromise = loadingPromise ?? entryPoint.root.load();
         throw loadingPromise;
       }
-      // $FlowFixMe[incompatible-cast] - trust me Flow, its entryPoint component
-      return (component: TEntryPointComponent);
+      // $FlowFixMe[incompatible-type] - trust me Flow, its entryPoint component
+      return component as TEntryPointComponent;
     },
-    queries: (preloadedQueries: TPreloadedQueries),
+    // $FlowFixMe[incompatible-type]
+    queries: preloadedQueries as TPreloadedQueries,
     rootModuleID: entryPoint.root.getModuleId(),
   };
 }
 
 function LazyLoadEntryPointContainer_DEPRECATED<
-  TEntryPointParams: {...},
+  TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries: {+[string]: PreloadedQuery<any>},
-  TPreloadedEntryPoints: {...},
-  TRuntimeProps: {...},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
+  TPreloadedEntryPoints extends {...},
+  TRuntimeProps extends {...},
   TExtraProps,
 >({
   entryPoint,

package/relay-hooks/MatchContainer.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {ComponentType, ElementType, ReactNode} from 'react';
+
+/**
+ * Renders the results of a data-driven dependency fetched with the `@match`
+ * directive. The `@match` directive can be used to specify a mapping of
+ * result types to the containers used to render those types. The result
+ * value is an opaque object that described which component was selected
+ * and a reference to its data. Use <MatchContainer/> to render these
+ * values.
+ *
+ * ## Example
+ *
+ * For example, consider a piece of media content that might be text or
+ * an image, where for clients that don't support images the application
+ * should fall back to rendering the image caption as text. @match can be
+ * used to dynamically select whether to render a given media item as
+ * an image or text (on the server) and then fetch the corresponding
+ * React component and its data dependencies (information about the
+ * image or about the text).
+ *
+ * ```
+ * // Media.react.js
+ *
+ * // Define a React component that uses <MatchContainer /> to render the
+ * // results of a @module selection
+ * function Media(props) {
+ *   const {media, ...restProps} = props;
+ *
+ *   const loader = moduleReference => {
+ *      // given the data returned by your server for the @module directive,
+ *      // return the React component (or throw a Suspense promise if
+ *      // it is loading asynchronously).
+ *      todo_returnModuleOrThrowPromise(moduleReference);
+ *   };
+ *   return <MatchContainer
+ *     loader={loader}
+ *     match={media.mediaAttachment}
+ *     props={restProps}
+ *   />;
+ * }
+ *
+ * module.exports = createSuspenseFragmentContainer(
+ *   Media,
+ *   {
+ *     media: graphql`
+ *       fragment Media_media on Media {
+ *         # ...
+ *         mediaAttachment @match {
+ *            ...ImageContainer_image @module(name: "ImageContainer.react")
+ *            ...TextContainer_text @module(name: "TextContainer.react")
+ *         }
+ *       }
+ *     `
+ *   },
+ * );
+ * ```
+ *
+ * ## API
+ *
+ * MatchContainer accepts the following props:
+ * - `match`: The results (an opaque object) of a `@match` field.
+ * - `props`: Props that should be passed through to the dynamically
+ *   selected component. Note that any of the components listed in
+ *   `@module()` could be selected, so all components should accept
+ *   the value passed here.
+ * - `loader`: A function to load a module given a reference (whatever
+ *   your server returns for the `js(moduleName: String)` field).
+ */
+
+type TypenameOnlyPointer = Readonly<{ __typename: string }>;
+export type MatchPointer = Readonly<{
+    __fragmentPropName?: string | null | undefined;
+    __module_component?: unknown | undefined;
+    ' $fragmentSpreads': unknown;
+}>;
+
+export type MatchContainerProps<TProps = Record<string, unknown>, TFallback = ReactNode> = Readonly<{
+    fallback?: TFallback | null | undefined;
+    loader: (module: unknown) => ComponentType<TProps>;
+    match?: MatchPointer | TypenameOnlyPointer | null | undefined;
+    props?: TProps | undefined;
+}>;
+
+export function MatchContainer<TProps = Record<string, unknown>, TFallback = ReactNode>(
+    props: MatchContainerProps<TProps, TFallback>,
+): ElementType<TProps> | TFallback | null;
+
+export {};

package/relay-hooks/MatchContainer.js.flow

@@ -85,22 +85,28 @@ const {useMemo} = React;
 
 // Note: this type is intentionally non-exact, it is expected that the
 // object may contain sibling fields.
-type TypenameOnlyPointer = {+__typename: string};
+type TypenameOnlyPointer = {readonly __typename: string};
 export type MatchPointer = {
-  +__fragmentPropName?: ?string,
-  +__module_component?: mixed,
-  +$fragmentSpreads: mixed,
+  readonly __fragmentPropName?: ?string,
+  readonly __module_component?: unknown,
+  readonly $fragmentSpreads: unknown,
   ...
 };
 
-export type MatchContainerProps<TProps: {...}, TFallback: React.Node> = {
-  +fallback?: ?TFallback,
-  +loader: (module: mixed) => component(...TProps),
-  +match: ?MatchPointer | ?TypenameOnlyPointer,
-  +props?: TProps,
+export type MatchContainerProps<
+  TProps extends {...},
+  TFallback extends React.Node,
+> = {
+  readonly fallback?: ?TFallback,
+  readonly loader: (module: unknown) => component(...TProps),
+  readonly match: ?MatchPointer | ?TypenameOnlyPointer,
+  readonly props?: TProps,
 };
 
-function MatchContainer<TProps: {...}, TFallback: React.Node | null>({
+function MatchContainer<
+  TProps extends {...},
+  TFallback extends React.Node | null,
+>({
   fallback,
   loader,
   match,
@@ -127,7 +133,7 @@ function MatchContainer<TProps: {...}, TFallback: React.Node | null>({
     __fragmentOwner,
     __fragmentPropName,
     __module_component,
-  } = (match: $FlowFixMe) ?? {};
+  } = (match as $FlowFixMe) ?? {};
   if (
     (__fragmentOwner != null && typeof __fragmentOwner !== 'object') ||
     (__fragmentPropName != null && typeof __fragmentPropName !== 'string') ||

package/relay-hooks/NestedRelayEntryPointBuilderUtils.js.flow

@@ -12,7 +12,7 @@
 'use strict';
 
 import type {
-  InternalEntryPointRepresentation,
+  EntryPoint,
   ThinNestedEntryPointParams,
 } from './EntryPointTypes.flow';
 
@@ -25,14 +25,8 @@ import type {
  * to construct a `ThinNestedEntryPointParams` is by calling this function.
  */
 declare function NestedRelayEntryPoint<TEntryPointParams>(
-  $ReadOnly<{
-    entryPoint: InternalEntryPointRepresentation<
-      TEntryPointParams,
-      $FlowFixMe,
-      $FlowFixMe,
-      $FlowFixMe,
-      $FlowFixMe,
-    >,
+  params: Readonly<{
+    entryPoint: EntryPoint<TEntryPointParams, $FlowFixMe>,
     entryPointParams: TEntryPointParams,
   }>,
 ): ThinNestedEntryPointParams;

package/relay-hooks/ProfilerContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// This contextual profiler can be used to wrap a react sub-tree. It will bind
+// the RelayProfiler during the render phase of these components. Allows
+// collecting metrics for a specific part of your application.
+
+import { Context } from 'react';
+
+export interface ProfilerContextType {
+    wrapPrepareQueryResource: <T>(cb: () => T) => T;
+}
+
+export const ProfilerContext: Context<ProfilerContextType>;