relay-runtime 21.0.0 → 21.0.1

package/util/RelayFeatureFlags.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { Disposable } from './RelayRuntimeTypes';
+
+export interface FeatureFlags {
+    ENABLE_VARIABLE_CONNECTION_KEY: boolean;
+    ENABLE_RELAY_RESOLVERS: boolean;
+    ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean;
+    ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean;
+    ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean;
+    ENABLE_NOTIFY_SUBSCRIPTION: boolean;
+    BATCH_ASYNC_MODULE_UPDATES_FN: null | undefined | ((callback: () => void) => Disposable);
+    ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: boolean;
+    MAX_DATA_ID_LENGTH: number | null | undefined;
+    STRING_INTERN_LEVEL: number;
+    LOG_MISSING_RECORDS_IN_PROD: boolean;
+    ENABLE_RELAY_OPERATION_TRACKER_SUSPENSE: boolean;
+    ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: boolean;
+    ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS: boolean;
+    ENABLE_LOOSE_SUBSCRIPTION_ATTRIBUTION: boolean;
+    ENABLE_OPERATION_TRACKER_OPTIMISTIC_UPDATES: boolean;
+    PROCESS_OPTIMISTIC_UPDATE_BEFORE_SUBSCRIPTION: boolean;
+    MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD: boolean;
+    ENABLE_CYLE_DETECTION_IN_VARIABLES: boolean;
+    ENABLE_ACTIVITY_COMPATIBILITY: boolean;
+    ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: boolean;
+    ENABLE_USE_PAGINATION_IS_LOADING_FIX: boolean;
+    ENABLE_STORE_ID_COLLISION_LOGGING: boolean;
+    DISALLOW_NESTED_UPDATES: boolean;
+    ENABLE_TYPENAME_PREFIXED_DATA_ID: boolean;
+    CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: boolean;
+    ENABLE_READER_FRAGMENTS_LOGGING: boolean;
+}
+
+export const RelayFeatureFlags: FeatureFlags;

package/util/RelayProfiler.d.ts

@@ -0,0 +1,121 @@
+/**
+ * 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.
+ */
+
+export type Handler = (name: string, callback: () => void) => void;
+export type ProfileHandler = (name: string, state?: any) => (error?: Error) => void;
+
+/**
+ * Instruments methods to allow profiling various parts of Relay. Profiling code
+ * in Relay consists of three steps:
+ *
+ *  - Instrument the function to be profiled.
+ *  - Attach handlers to the instrumented function.
+ *  - Run the code which triggers the handlers.
+ *
+ * Handlers attached to instrumented methods are called with an instrumentation
+ * name and a callback that must be synchronously executed:
+ *
+ *   instrumentedMethod.attachHandler(function(name, callback) {
+ *     const start = performance.now();
+ *     callback();
+ *     console.log('Duration', performance.now() - start);
+ *   });
+ *
+ * Handlers for profiles are callbacks that return a stop method:
+ *
+ *   RelayProfiler.attachProfileHandler('profileName', (name, state) => {
+ *     const start = performance.now();
+ *     return function stop(name, state) {
+ *       console.log(`Duration (${name})`, performance.now() - start);
+ *     }
+ *   });
+ *
+ * In order to reduce the impact on performance in production, instrumented
+ * methods and profilers with names that begin with `@` will only be measured
+ * if `__DEV__` is true. This should be used for very hot functions.
+ */
+
+export const RelayProfiler: {
+    /**
+     * Instruments methods on a class or object. This re-assigns the method in
+     * order to preserve function names in stack traces (which are detected by
+     * modern debuggers via heuristics). Example usage:
+     *
+     *   const RelayStore = { primeCache: function() {...} };
+     *   RelayProfiler.instrumentMethods(RelayStore, {
+     *     primeCache: 'RelayStore.primeCache'
+     *   });
+     *
+     *   RelayStore.primeCache.attachHandler(...);
+     *
+     * As a result, the methods will be replaced by wrappers that provide the
+     * `attachHandler` and `detachHandler` methods.
+     */
+    instrumentMethods(object: () => void | object, names: { [key: string]: string }): void;
+
+    /**
+     * Wraps the supplied function with one that provides the `attachHandler` and
+     * `detachHandler` methods. Example usage:
+     *
+     *   const printRelayQuery =
+     *     RelayProfiler.instrument('printRelayQuery', printRelayQuery);
+     *
+     *   printRelayQuery.attachHandler(...);
+     *
+     * NOTE: The instrumentation assumes that no handlers are attached or detached
+     * in the course of executing another handler.
+     */
+    instrument<T extends () => void>(name: string, originalFunction: T): T;
+
+    /**
+     * Attaches a handler to all methods instrumented with the supplied name.
+     *
+     *   function createRenderer() {
+     *     return RelayProfiler.instrument('render', function() {...});
+     *   }
+     *   const renderA = createRenderer();
+     *   const renderB = createRenderer();
+     *
+     *   // Only profiles `renderA`.
+     *   renderA.attachHandler(...);
+     *
+     *   // Profiles both `renderA` and `renderB`.
+     *   RelayProfiler.attachAggregateHandler('render', ...);
+     */
+    attachAggregateHandler(name: string, handler: Handler): void;
+
+    /**
+     * Detaches a handler attached via `attachAggregateHandler`.
+     */
+    detachAggregateHandler(name: string, handler: Handler): void;
+
+    /**
+     * Instruments profiling for arbitrarily asynchronous code by a name.
+     *
+     *   const timerProfiler = RelayProfiler.profile('timeout');
+     *   setTimeout(function() {
+     *     timerProfiler.stop();
+     *   }, 1000);
+     *
+     *   RelayProfiler.attachProfileHandler('timeout', ...);
+     *
+     * Arbitrary state can also be passed into `profile` as a second argument. The
+     * attached profile handlers will receive this as the second argument.
+     */
+    profile(name: string, state?: any): { stop: (error?: Error) => void };
+
+    /**
+     * Attaches a handler to profiles with the supplied name. You can also
+     * attach to the special name '*' which is a catch all.
+     */
+    attachProfileHandler(name: string, handler: ProfileHandler): void;
+
+    /**
+     * Detaches a handler attached via `attachProfileHandler`.
+     */
+    detachProfileHandler(name: string, handler: ProfileHandler): void;
+};

package/util/RelayReplaySubject.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 type {Observer, Sink, Subscription} from '../network/RelayObservable';
+
+export type Event<T> = { kind: 'next'; data: T } | { kind: 'error'; error: Error } | { kind: 'complete' };
+
+/**
+ * An implementation of a `ReplaySubject` for Relay Observables.
+ *
+ * Records events provided and synchronously plays them back to new subscribers,
+ * as well as forwarding new asynchronous events.
+ */
+export class RelayReplaySubject<T> {
+    complete(): void;
+    error(error: Error): void;
+    next(data: T): void;
+    subscribe(observer: Observer<T> | Sink<T>): Subscription;
+    unsubscribe(): void;
+    getObserverCount(): number;
+}

package/util/RelayRuntimeTypes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+
+/**
+ * Represents any resource that must be explicitly disposed of. The most common
+ * use-case is as a return value for subscriptions, where calling `dispose()`
+ * would cancel the subscription.
+ */
+export interface Disposable {
+    dispose: DisposeFn;
+}
+
+export type DataID = string;
+
+export interface Variables {
+    [name: string]: any;
+}
+
+export interface OperationType {
+    readonly variables: Variables;
+    readonly response: unknown;
+    readonly rawResponse?: unknown | undefined;
+}
+
+export type VariablesOf<TQuery extends OperationType> = TQuery['variables'];
+
+export type DisposeFn = () => void;
+
+/**
+ * Settings for how a query response may be cached.
+ *
+ * - `force`: causes a query to be issued unconditionally, irrespective of the
+ *   state of any configured response cache.
+ * - `poll`: causes a query to live update by polling at the specified interval
+ *   in milliseconds. (This value will be passed to setTimeout.)
+ * - `liveConfigId`: causes a query to live update by calling GraphQLLiveQuery,
+ *   it represents a configuration of gateway when doing live query
+ * - `metadata`: user-supplied metadata.
+ * - `transactionId`: a user-supplied value, intended for use as a unique id for
+ *   a given instance of executing an operation.
+ */
+export interface CacheConfig {
+    force?: boolean | null | undefined;
+    poll?: number | null | undefined;
+    liveConfigId?: string | null | undefined;
+    metadata?: { [key: string]: unknown } | undefined;
+    transactionId?: string | null | undefined;
+}
+
+/**
+ * Experimental
+ */
+export type FetchQueryFetchPolicy = 'store-or-network' | 'network-only';
+export type FetchPolicy = FetchQueryFetchPolicy | 'store-and-network' | 'store-only';
+export type RenderPolicy = 'full' | 'partial';

package/util/RelayRuntimeTypes.js.flow

@@ -32,16 +32,16 @@ export type Disposable = interface {dispose(): void};
 export type DataID = string;
 
 // Variables
-export type Variables = {+[string]: $FlowFixMe};
+export type Variables = {readonly [string]: $FlowFixMe};
 
 /**
  * Generated operation flow types are subtypes of this.
  */
 export type OperationType = {
   // TODO(T33395812) Make this an open object type
-  +variables: Variables,
-  +response: unknown,
-  +rawResponse?: {...},
+  readonly variables: Variables,
+  readonly response: unknown,
+  readonly rawResponse?: {...},
 };
 
 export type VariablesOf<T extends OperationType> = T['variables'];
@@ -62,14 +62,17 @@ export type VariablesOf<T extends OperationType> = T['variables'];
  *   a given instance of executing an operation.
  */
 export type CacheConfig = {
-  +force?: ?boolean,
-  +poll?: ?number,
-  +liveConfigId?: ?string,
-  +onSubscribe?: () => void,
-  +onResume?: (pauseTimeMs: number) => void,
-  +onPause?: (mqttConnectionIsOk: boolean, internetIsOk: boolean) => void,
-  +metadata?: {+[key: string]: unknown, ...},
-  +transactionId?: ?string,
+  readonly force?: ?boolean,
+  readonly poll?: ?number,
+  readonly liveConfigId?: ?string,
+  readonly onSubscribe?: () => void,
+  readonly onResume?: (pauseTimeMs: number) => void,
+  readonly onPause?: (
+    mqttConnectionIsOk: boolean,
+    internetIsOk: boolean,
+  ) => void,
+  readonly metadata?: {readonly [key: string]: unknown, ...},
+  readonly transactionId?: ?string,
 };
 
 export type FetchQueryFetchPolicy = 'store-or-network' | 'network-only';
@@ -86,8 +89,8 @@ export type RenderPolicy = 'full' | 'partial';
  * Return type of graphql tag literals for all operations.
  */
 declare export opaque type Operation<
-  -TVariables extends Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse,
 >: ConcreteRequest;
 
@@ -95,8 +98,8 @@ declare export opaque type Operation<
  * Return type of graphql tag literals for updatable queries.
  */
 declare export opaque type UpdatableQuery<
-  -TVariables extends Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
 >: ConcreteUpdatableQuery;
 
 /**
@@ -104,15 +107,15 @@ declare export opaque type UpdatableQuery<
  */
 declare export opaque type UpdatableFragment<
   TFragmentType,
-  +TData,
+  out TData,
 >: ReaderFragment;
 
 /**
  * Return type of graphql tag literals for queries.
  */
 declare export opaque type Query<
-  -TVariables extends Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = void,
 >: Operation<TVariables, TData, TRawResponse>;
 
@@ -120,8 +123,8 @@ declare export opaque type Query<
  * Return type of graphql tag literals for client-only queries.
  */
 declare export opaque type ClientQuery<
-  -TVariables extends Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = void,
 >: ClientRequest;
 
@@ -129,8 +132,8 @@ declare export opaque type ClientQuery<
  * Return type of graphql tag literals for mutations.
  */
 declare export opaque type Mutation<
-  -TVariables extends Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = {...},
 >: Operation<TVariables, TData, TRawResponse>;
 
@@ -141,8 +144,8 @@ declare export opaque type Mutation<
  *       `RelayObservable`'s `Subscription` type.
  */
 declare export opaque type GraphQLSubscription<
-  -TVariables extends Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = void,
 >: Operation<TVariables, TData, TRawResponse>;
 
@@ -151,21 +154,21 @@ declare export opaque type GraphQLSubscription<
  */
 declare export opaque type InlineFragment<
   TFragmentType,
-  +TData,
+  out TData,
 >: ReaderInlineDataFragment;
 
 /**
  * Return type of graphql tag literals for fragments, except `@inline`
  * fragments.
  */
-declare export opaque type Fragment<TFragmentType, +TData>: ReaderFragment;
+declare export opaque type Fragment<TFragmentType, out TData>: ReaderFragment;
 
 /**
  * Return type of graphql tag literals for `@refetchable` fragments.
  */
 declare export opaque type RefetchableFragment<
   TFragmentType,
-  +TData,
+  out TData,
   TVariables extends Variables,
 >: Fragment<TFragmentType, TData>;
 
@@ -175,7 +178,7 @@ declare export opaque type RefetchableFragment<
  */
 declare export opaque type PrefetchableRefetchableFragment<
   TFragmentType,
-  +TData,
-  +TEdgeData,
+  out TData,
+  out TEdgeData,
   TVariables extends Variables,
 >: Fragment<TFragmentType, TData>;

package/util/createPayloadFor3DField.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 type {JSResourceReference, NormalizationSplitOperation} from './NormalizationNode';
+
+export type Local3DPayload<_DocumentName extends string, Response extends Record<string, unknown>> = Response;
+
+export default function createPayloadFor3DField<DocumentName extends string, Response extends Record<string, unknown>>(
+    name: DocumentName,
+    operation: JSResourceReference<NormalizationSplitOperation>,
+    component: JSResourceReference<unknown>,
+    response: Response,
+): Local3DPayload<DocumentName, Response>;

package/util/createPayloadFor3DField.js.flow

@@ -21,15 +21,15 @@ const {
 
 export opaque type Local3DPayload<
   // eslint-disable-next-line no-unused-vars
-  +DocumentName extends string,
-  +Response extends {...},
+  out DocumentName extends string,
+  out Response extends {...},
 > = Response;
 
 function createPayloadFor3DField<
   // $FlowFixMe[unsupported-variance-annotation]
-  +DocumentName extends string,
+  out DocumentName extends string,
   // $FlowFixMe[unsupported-variance-annotation]
-  +Response extends {...},
+  out Response extends {...},
 >(
   name: DocumentName,
   operation: JSResourceReference<NormalizationSplitOperation>,

package/util/deepFreeze.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function deepFreeze<T extends object>(value: T): T;

package/util/getFragmentIdentifier.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { ReaderFragment } from './ReaderNode';
+
+export default function getFragmentIdentifier(fragmentNode: ReaderFragment, fragmentRef: any): string;

package/util/getPaginationMetadata.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 {ReaderFragment, ReaderPaginationMetadata} from './ReaderNode';
+import { ConcreteRequest } from './RelayConcreteNode';
+
+export default function getPaginationMetadata(
+    fragmentNode: ReaderFragment,
+    componentDisplayName: string,
+): {
+    connectionPathInFragmentData: ReadonlyArray<string | number>;
+    identifierField: string | null | undefined;
+    paginationRequest: ConcreteRequest;
+    paginationMetadata: ReaderPaginationMetadata;
+    stream: boolean;
+};

package/util/getPaginationVariables.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { ReaderPaginationMetadata } from './ReaderNode';
+import { Variables } from './RelayRuntimeTypes';
+
+export type Direction = 'forward' | 'backward';
+
+export default function getPaginationVariables(
+    direction: Direction,
+    count: number,
+    cursor: string | null | undefined,
+    baseVariables: Variables,
+    extraVariables: Variables,
+    paginationMetadata: ReaderPaginationMetadata,
+): { [key: string]: any };

package/util/getPendingOperationsForFragment.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.
+ */
+
+import type {Environment, RequestDescriptor} from '../store/RelayStoreTypes';
+import type { ReaderFragment } from './ReaderNode';
+
+export default function getPendingOperationsForFragment(
+    environment: Environment,
+    fragmentNode: ReaderFragment,
+    fragmentOwner: RequestDescriptor,
+): {
+    promise: Promise<void>;
+    pendingOperations: readonly RequestDescriptor[];
+} | null;

package/util/getRefetchMetadata.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 {ReaderFragment, ReaderRefetchMetadata, RefetchableIdentifierInfo} from './ReaderNode';
+import { ConcreteRequest } from './RelayConcreteNode';
+
+export default function getRefetchMetadata(
+    fragmentNode: ReaderFragment,
+    componentDisplayName: string,
+): {
+    fragmentRefPathInResponse: ReadonlyArray<string | number>;
+    identifierInfo: RefetchableIdentifierInfo | null | undefined;
+    refetchableRequest: ConcreteRequest;
+    refetchMetadata: ReaderRefetchMetadata;
+};

package/util/getRelayHandleKey.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function getRelayHandleKey(handleName: string, key?: string | null, fieldName?: string | null): string;

package/util/getRequestIdentifier.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { RequestParameters } from './RelayConcreteNode';
+import { Variables } from './RelayRuntimeTypes';
+
+export type RequestIdentifier = string;
+
+/**
+ * Returns a stable identifier for the given pair of `RequestParameters` +
+ * variables.
+ */
+export default function getRequestIdentifier(parameters: RequestParameters, variables: Variables): RequestIdentifier;

package/util/getValueAtPath.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function getValueAtPath(data: any, path: ReadonlyArray<string | number>): any;

package/util/handlePotentialSnapshotErrors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 {Environment, MissingRequiredFields, RelayResolverErrors} from '../store/RelayStoreTypes';
+
+export default function handlePotentialSnapshotErrors(
+    environment: Environment,
+    missingRequiredFields: MissingRequiredFields | null | undefined,
+    relayResolverErrors: RelayResolverErrors,
+): void;

package/util/isEmptyObject.js.flow

@@ -14,7 +14,7 @@
 // $FlowFixMe[method-unbinding] added when improving typing for this parameters
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-function isEmptyObject(obj: {+[key: string]: unknown}): boolean {
+function isEmptyObject(obj: {readonly [key: string]: unknown}): boolean {
   for (const key in obj) {
     if (hasOwnProperty.call(obj, key)) {
       return false;

package/util/isPromise.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function isPromise(p: any): p is Promise<any>;

package/util/isScalarAndEqual.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function isScalarAndEqual(valueA: unknown, valueB: unknown): boolean;

package/util/recycleNodesInto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function recycleNodesInto<T>(prevData: T, nextData: T): T;

package/util/stableCopy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function stableCopy<T>(value: T): T;

package/util/withProvidedVariables.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { ProvidedVariablesType } from './RelayConcreteNode';
+import { Variables } from './RelayRuntimeTypes';
+
+interface WithProvidedVariablesFn {
+    (
+        userSuppliedVariables: Variables,
+        providedVariables: ProvidedVariablesType | null | undefined,
+    ): Variables;
+    tests_only_resetDebugCache: undefined | (() => void);
+}
+declare const withProvidedVariables: WithProvidedVariablesFn;
+export default withProvidedVariables;