From 7560d8386a1ae229bdc6b34e5b0c5f3d89a9b667 Mon Sep 17 00:00:00 2001 From: ChrisRast Date: Thu, 8 Dec 2022 16:25:42 +0100 Subject: [PATCH 1/7] Add counterpart 0.18 (#4411) * Add counterpart 0.18 * Improve export to match reality --- .../flow_v0.83.x-/counterpart_v0.18.x.js | 46 ++++++++++ .../flow_v0.83.x-/test_counterpart_v0.18.x.js | 92 +++++++++++++++++++ 2 files changed, 138 insertions(+) create mode 100644 definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/counterpart_v0.18.x.js create mode 100644 definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/test_counterpart_v0.18.x.js diff --git a/definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/counterpart_v0.18.x.js b/definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/counterpart_v0.18.x.js new file mode 100644 index 0000000000..a30070cdd5 --- /dev/null +++ b/definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/counterpart_v0.18.x.js @@ -0,0 +1,46 @@ +// Type definitions for counterpart 0.18 adapted from TypeScript +// Project: https://github.com/martinandert/counterpart +// TS Definitions by: santiagodoldan +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +declare module 'counterpart' { + declare type NotFoundHandler = ( + locale: string, + key: string, + fallback: string, + scope: string + ) => void; + declare type LocaleChangeHandler = ( + newLocale: string, + oldLocale: string + ) => void; + + declare function translate(key: string | string[], options?: { ... }): string; + + declare class Counterpart { + constructor(): this; + + translate: typeof translate; + setSeparator(value: string): string; + onTranslationNotFound(callback: NotFoundHandler): void; + offTranslationNotFound(callback: NotFoundHandler): void; + setMissingEntryGenerator(callback: (value: string) => void): void; + getLocale(): string; + setLocale(value: string): string; + onLocaleChange(callback: LocaleChangeHandler): void; + offLocaleChange(callback: LocaleChangeHandler): void; + setFallbackLocale(value: string | string[]): void; + registerTranslations(locale: string, data: { ... }): void; + registerInterpolations(data: { ... }): void; + setKeyTransformer( + callback: (value: string, options: { ... }) => string + ): string; + localize(date: Date, options: { ... }): string; + } + + declare module.exports: {| + Instance: Class, + Translator: Class, + |} & Counterpart & + typeof translate; +} diff --git a/definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/test_counterpart_v0.18.x.js b/definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/test_counterpart_v0.18.x.js new file mode 100644 index 0000000000..be1ed568eb --- /dev/null +++ b/definitions/npm/counterpart_v0.18.x/flow_v0.83.x-/test_counterpart_v0.18.x.js @@ -0,0 +1,92 @@ +// @flow +import { describe, it } from 'flow-typed-test'; +import Counterpart from 'counterpart'; +import type { NotFoundHandler, LocaleChangeHandler } from 'counterpart'; + +describe('counterpart', () => { + // This matches the readme example. + it('should be the translate reference from the export', () => { + const translate = require('counterpart'); + translate('text'); + translate.getLocale(); + translate.setLocale('locale'); + }); + it('should be a callable class from the Instance export', () => { + const instance = new Counterpart.Instance(); + instance.translate('text'); + }); + it('should be a callable class from the Translator export', () => { + const instance = new Counterpart.Translator(); + instance.translate('text'); + }); + it('accepts options', () => { + const instance = new Counterpart.Instance(); + instance.translate('text', { + bar: 'baz', + }); + instance.translate('text', { + count: 1, + }); + instance.translate('text', { + fallback: 'default', + }); + }); + + describe('methods', () => { + const instance = new Counterpart.Instance(); + + it('setSeparator', () => { + instance.setSeparator('*'); + }); + + it('registerTranslations', () => { + instance.registerTranslations('locale', {}); + + // $FlowExpectedError[incompatible-call] + instance.registerTranslations('locale', 'translation'); + }); + + it('setLocale', () => { + instance.setLocale('locale'); + + // $FlowExpectedError[incompatible-call] + instance.setLocale({}); + }); + + it('getLocale', () => { + let locale: string = instance.getLocale(); + + // $FlowExpectedError[extra-arg] + instance.getLocale('locale'); + }); + + it('setFallbackLocale', () => { + instance.setFallbackLocale('locale'); + instance.setFallbackLocale(['locale']); + }); + + it('onTranslationNotFound', () => { + const callback: NotFoundHandler = (locale, key) => { + // nothing + }; + instance.onTranslationNotFound(callback); + + instance.onTranslationNotFound( + // $FlowExpectedError[incompatible-call] + (locale: number, key: boolean, fallback: () => void, scope: null) => {} + ); + }); + + it('onLocaleChange', () => { + const callback: LocaleChangeHandler = () => { + // nothing + }; + instance.onLocaleChange(callback); + + instance.onLocaleChange( + // $FlowExpectedError[incompatible-call] + (locale: number, key: boolean, fallback: () => void, scope: null) => {} + ); + }); + }); +}); From d343d4765331b55170a0bf240de476ce06e22af2 Mon Sep 17 00:00:00 2001 From: ChrisRast Date: Thu, 8 Dec 2022 20:56:51 +0100 Subject: [PATCH 2/7] Add Glob v8 libdef (#4412) - Simple copy/paste/rename of the v7 libdef - Add type import in test to fix error since flow 0.189 --- .../glob_v8.x.x/flow_v0.104.x-/glob_v8.x.x.js | 76 ++++++++ .../flow_v0.42.x-v0.103.x/glob_v8.x.x.js | 84 +++++++++ .../npm/glob_v8.x.x/test_glob_v8.x.x.js | 164 ++++++++++++++++++ 3 files changed, 324 insertions(+) create mode 100644 definitions/npm/glob_v8.x.x/flow_v0.104.x-/glob_v8.x.x.js create mode 100644 definitions/npm/glob_v8.x.x/flow_v0.42.x-v0.103.x/glob_v8.x.x.js create mode 100644 definitions/npm/glob_v8.x.x/test_glob_v8.x.x.js diff --git a/definitions/npm/glob_v8.x.x/flow_v0.104.x-/glob_v8.x.x.js b/definitions/npm/glob_v8.x.x/flow_v0.104.x-/glob_v8.x.x.js new file mode 100644 index 0000000000..55495f5606 --- /dev/null +++ b/definitions/npm/glob_v8.x.x/flow_v0.104.x-/glob_v8.x.x.js @@ -0,0 +1,76 @@ +declare module "glob" { + declare type MinimatchOptions = {| + debug?: boolean, + nobrace?: boolean, + noglobstar?: boolean, + dot?: boolean, + noext?: boolean, + nocase?: boolean, + nonull?: boolean, + matchBase?: boolean, + nocomment?: boolean, + nonegate?: boolean, + flipNegate?: boolean + |}; + + declare type Options = {| + ...MinimatchOptions, + cwd?: string, + root?: string, + nomount?: boolean, + mark?: boolean, + nosort?: boolean, + stat?: boolean, + silent?: boolean, + strict?: boolean, + cache?: { [path: string]: boolean | "DIR" | "FILE" | $ReadOnlyArray, ... }, + statCache?: { [path: string]: boolean | { isDirectory(): boolean, ... } | void, ... }, + symlinks?: { [path: string]: boolean | void, ... }, + realpathCache?: { [path: string]: string, ... }, + sync?: boolean, + nounique?: boolean, + nodir?: boolean, + ignore?: string | $ReadOnlyArray, + follow?: boolean, + realpath?: boolean, + absolute?: boolean + |}; + + /** + * Called when an error occurs, or matches are found + * err + * matches: filenames found matching the pattern + */ + declare type CallBack = (err: ?Error, matches: Array) => void; + + declare class Glob extends events$EventEmitter { + constructor(pattern: string): this; + constructor(pattern: string, callback: CallBack): this; + constructor(pattern: string, options: Options, callback: CallBack): this; + + minimatch: {...}; + options: Options; + aborted: boolean; + cache: { [path: string]: boolean | "DIR" | "FILE" | $ReadOnlyArray, ... }; + statCache: { [path: string]: boolean | { isDirectory(): boolean, ... } | void, ... }; + symlinks: { [path: string]: boolean | void, ... }; + realpathCache: { [path: string]: string, ... }; + found: Array; + + pause(): void; + resume(): void; + abort(): void; + } + + declare class GlobModule { + Glob: Class; + + (pattern: string, callback: CallBack): void; + (pattern: string, options: Options, callback: CallBack): void; + + hasMagic(pattern: string, options?: Options): boolean; + sync(pattern: string, options?: Options): Array; + } + + declare module.exports: GlobModule; +} diff --git a/definitions/npm/glob_v8.x.x/flow_v0.42.x-v0.103.x/glob_v8.x.x.js b/definitions/npm/glob_v8.x.x/flow_v0.42.x-v0.103.x/glob_v8.x.x.js new file mode 100644 index 0000000000..e36da206bb --- /dev/null +++ b/definitions/npm/glob_v8.x.x/flow_v0.42.x-v0.103.x/glob_v8.x.x.js @@ -0,0 +1,84 @@ +declare module "glob" { + declare type MinimatchOptions = {| + debug?: boolean, + nobrace?: boolean, + noglobstar?: boolean, + dot?: boolean, + noext?: boolean, + nocase?: boolean, + nonull?: boolean, + matchBase?: boolean, + nocomment?: boolean, + nonegate?: boolean, + flipNegate?: boolean + |}; + + declare type Options = {| + ...MinimatchOptions, + cwd?: string, + root?: string, + nomount?: boolean, + mark?: boolean, + nosort?: boolean, + stat?: boolean, + silent?: boolean, + strict?: boolean, + cache?: { + [path: string]: boolean | "DIR" | "FILE" | $ReadOnlyArray + }, + statCache?: { + [path: string]: boolean | { isDirectory(): boolean } | void + }, + symlinks?: { [path: string]: boolean | void }, + realpathCache?: { [path: string]: string }, + sync?: boolean, + nounique?: boolean, + nodir?: boolean, + ignore?: string | $ReadOnlyArray, + follow?: boolean, + realpath?: boolean, + absolute?: boolean + |}; + + /** + * Called when an error occurs, or matches are found + * err + * matches: filenames found matching the pattern + */ + declare type CallBack = (err: ?Error, matches: Array) => void; + + declare class Glob extends events$EventEmitter { + constructor(pattern: string): this; + constructor(pattern: string, callback: CallBack): this; + constructor(pattern: string, options: Options, callback: CallBack): this; + + minimatch: {}; + options: Options; + aborted: boolean; + cache: { + [path: string]: boolean | "DIR" | "FILE" | $ReadOnlyArray + }; + statCache: { + [path: string]: boolean | { isDirectory(): boolean } | void + }; + symlinks: { [path: string]: boolean | void }; + realpathCache: { [path: string]: string }; + found: Array; + + pause(): void; + resume(): void; + abort(): void; + } + + declare class GlobModule { + Glob: Class; + + (pattern: string, callback: CallBack): void; + (pattern: string, options: Options, callback: CallBack): void; + + hasMagic(pattern: string, options?: Options): boolean; + sync(pattern: string, options?: Options): Array; + } + + declare module.exports: GlobModule; +} diff --git a/definitions/npm/glob_v8.x.x/test_glob_v8.x.x.js b/definitions/npm/glob_v8.x.x/test_glob_v8.x.x.js new file mode 100644 index 0000000000..74c70fbb95 --- /dev/null +++ b/definitions/npm/glob_v8.x.x/test_glob_v8.x.x.js @@ -0,0 +1,164 @@ +// @flow + +import { describe, it } from 'flow-typed-test'; +import glob, { type Options, type CallBack } from 'glob'; +const Glob = glob.Glob; + +let pattern = '**/*.js'; +let callback: CallBack = (err, matches) => {}; +let options = { + debug: true, + nobrace: true, + noglobstar: true, + dot: true, + noext: true, + nocase: true, + nonull: true, + matchBase: true, + nocomment: true, + nonegate: true, + flipNegate: true, + cwd: '', + root: '', + nomount: true, + mark: true, + nosort: true, + stat: true, + silent: true, + strict: true, + cache: { + test: true, + }, + statCache: { + test: true, + }, + symlinks: { test: true }, + realpathCache: { test: '' }, + sync: true, + nounique: true, + nodir: true, + ignore: '', + follow: true, + realpath: true, + absolute: true, +}; + +describe('The `glob` function', () => { + it('should validate the pattern, callback signature', () => { + glob(pattern, callback); + // $FlowExpectedError[incompatible-call] + glob(pattern); + // $FlowExpectedError[incompatible-call] + glob({}, {}); + }); + + it('should validate the pattern, options, callback signature', () => { + glob(pattern, options, callback); + // $FlowExpectedError[incompatible-call] + glob(pattern, options); + // $FlowExpectedError[incompatible-call] + glob(pattern, callback, options); + }); + + it('should return undefined', () => { + (glob(pattern, callback): void); + // $FlowExpectedError[incompatible-cast] + (glob(pattern, callback): boolean); + }); +}); + +describe('The `glob.hasMagic` function', () => { + it('should accept a string for its `pattern` parameter', () => { + glob.hasMagic(pattern); + // $FlowExpectedError[incompatible-call] + glob.hasMagic({}); + }); + + it('should accept an object for its `options` parameter', () => { + glob.hasMagic(pattern, {}); + glob.hasMagic(pattern, options); + // $FlowExpectedError[incompatible-exact] + glob.hasMagic(pattern, callback); + }); + + it('should return a boolean', () => { + (glob.hasMagic(pattern): boolean); + // $FlowExpectedError[incompatible-cast] + (glob.hasMagic(pattern): string); + }); +}); + +describe('The `glob.sync` function', () => { + it('should accept a string for its `pattern` parameter', () => { + glob.sync(pattern); + // $FlowExpectedError[incompatible-call] + glob.sync({}); + }); + + it('should accept an object for its `options` parameter', () => { + glob.sync(pattern, {}); + glob.sync(pattern, options); + // $FlowExpectedError[incompatible-exact] + glob.sync(pattern, callback); + }); + + it('should return a matches Array', () => { + (glob.sync(pattern): Array); + // $FlowExpectedError[incompatible-cast] + (glob.sync(pattern): string); + }); +}); + +describe('The `Glob` constructor', () => { + it('should validate the pattern signature', () => { + new Glob(pattern); + // $FlowExpectedError[incompatible-call] + new Glob({}); + }); + + it('should validate the pattern, callback signature', () => { + new Glob(pattern, callback); + // $FlowExpectedError[incompatible-call] + new Glob(pattern, options); + }); + + it('should validate the pattern, options, callback signature', () => { + new Glob(pattern, options, callback); + // $FlowExpectedError[incompatible-call] + new Glob(pattern, callback, options); + }); +}); + +describe('The `Glob` properties', () => { + it('should validate on default usage', () => { + let mg = new Glob(''); + (mg.aborted: boolean); + (mg.cache: $PropertyType); + (mg.statCache: $PropertyType); + }); +}); + +describe('The `Glob` events', () => { + it('should validate on default usage', () => { + let mg = new Glob(''); + mg.on('end', () => {}); + mg.on('match', () => {}); + mg.on('error', () => {}); + mg.on('abort', () => {}); + }); +}); + +describe('The `Glob` methods', () => { + it('should validate on default usage', () => { + let mg = new Glob(''); + mg.pause(); + mg.resume(); + mg.abort(); + // $FlowExpectedError[extra-arg] + mg.pause(() => {}); + // $FlowExpectedError[extra-arg] + mg.resume(() => {}); + // $FlowExpectedError[extra-arg] + mg.abort(() => {}); + }); +}); From 945e0acf5d031845ba697570e91881c33382c61c Mon Sep 17 00:00:00 2001 From: Joshua Napoli Date: Tue, 3 Jan 2023 04:47:59 -0500 Subject: [PATCH 3/7] Add @apollo/client libdef (#4415) * Add @apollo/client libdef * Export useSubscription hook * Link classes extend ApolloLink Making ApolloClient global so that it can be shared across multiple module declarations * Export un-mangled names --- .../flow_v0.142.x-/client_v3.x.x.js | 2811 +++++++++++++++++ .../flow_v0.142.x-/test_client_v3.x.x.js | 130 + 2 files changed, 2941 insertions(+) create mode 100644 definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/client_v3.x.x.js create mode 100644 definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/test_client_v3.x.x.js diff --git a/definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/client_v3.x.x.js b/definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/client_v3.x.x.js new file mode 100644 index 0000000000..b80cf2a3ad --- /dev/null +++ b/definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/client_v3.x.x.js @@ -0,0 +1,2811 @@ +// Typescript Built-in Types + +declare interface TypeScript$IArguments { + [index: number]: any; + length: number; + callee: Function; +} + +// zen-observable-ts + +declare interface ZenObservable$SubscriptionObserver { + closed: boolean; + next(value: T): void; + error(errorValue: any): void; + complete(): void; +} +declare interface ZenObservable$Subscription { + closed: boolean; + unsubscribe(): void; +} +declare type ZenObservable$Subscriber = ( + observer: ZenObservable$SubscriptionObserver, +) => void | (() => void) | ZenObservable$Subscription; +declare interface ZenObservable$Observer { + start?: (subscription: ZenObservable$Subscription) => any; + next?: (value: T) => void; + error?: (errorValue: any) => void; + complete?: () => void; +}; +declare type ZenObservable$ObservableSubscription = any; +declare interface ZenObservable$ObservableLike { + subscribe?: ZenObservable$Subscriber; +} +declare class ZenObservable$Observable { + constructor(subscriber: ZenObservable$Subscriber): ZenObservable$Observable; + static call(instance: ZenObservable$Observable, subscriber: ZenObservable$Subscriber): void; + static apply(instance: ZenObservable$Observable, args: TypeScript$IArguments | [ZenObservable$Subscriber]): void; + + subscribe(observer: ZenObservable$Observer): ZenObservable$ObservableSubscription; + subscribe( + onNext: (value: T) => void, + onError?: (error: any) => void, + onComplete?: () => void + ): ZenObservable$ObservableSubscription; + + forEach(callback: (value: T) => void): Promise; + map(callback: (value: T) => R): ZenObservable$Observable; + filter(callback: (value: T) => boolean): ZenObservable$Observable; + reduce(callback: (previousValue: T, currentValue: T) => T, initialValue?: T): ZenObservable$Observable; + reduce(callback: (previousValue: R, currentValue: T) => R, initialValue?: R): ZenObservable$Observable; + flatMap(callback: (value: T) => ZenObservable$ObservableLike): ZenObservable$Observable; + concat(...observable: Array>): ZenObservable$Observable; + + static from(observable: ZenObservable$Observable | ZenObservable$ObservableLike | $ReadOnlyArray): ZenObservable$Observable; + static of(...items: R[]): ZenObservable$Observable; +} + +// graphql + +declare class GraphQL$GraphQLError extends Error {} +declare type GraphQL$DocumentNode = Object; +declare interface GraphQL$ObjMap { + [key: string]: T; +} +declare interface GraphQL$ExecutionResult< + TData = GraphQL$ObjMap, + TExtensions = GraphQL$ObjMap, +> { + errors?: $ReadOnlyArray; + data?: TData | null; + extensions?: TExtensions; +} + +// @apollo/client/link/core/types.d.ts +// Globals to support global ApolloLink class +declare interface ApolloClient$Operation { + query: GraphQL$DocumentNode; + variables: { [key: string]: any, ... }; + operationName: string; + extensions: { [key: string]: any, ... }; + setContext: (context: { [key: string]: any, ... }) => { + [key: string]: any, + ..., + }; + getContext: () => { [key: string]: any, ... }; +} +declare type ApolloClient$Path = $ReadOnlyArray; +declare type ApolloClient$Data = T | null | void; +declare type ApolloClient$SingleExecutionResult< + TData = { [key: string]: any, ... }, + TContext = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } +> = { + data?: ApolloClient$Data, + context?: TContext, + ... +} & GraphQL$ExecutionResult; +declare interface ApolloClient$ExecutionPatchResultBase { + hasNext?: boolean; +} +declare interface ApolloClient$IncrementalPayload { + data: ApolloClient$Data; + label?: string; + path: ApolloClient$Path; + errors?: $ReadOnlyArray; + extensions?: TExtensions; +} +declare type ApolloClient$ExecutionPatchIncrementalResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } +> = { + incremental?: ApolloClient$IncrementalPayload[], + data?: empty, + errors?: empty, + extensions?: empty, + ... +} & ApolloClient$ExecutionPatchResultBase; +declare type ApolloClient$ExecutionPatchInitialResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } +> = { + data: ApolloClient$Data, + incremental?: empty, + errors?: $ReadOnlyArray, + extensions?: TExtensions, + ... +} & ApolloClient$ExecutionPatchResultBase; +declare type ApolloClient$ExecutionPatchResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } +> = ApolloClient$ExecutionPatchInitialResult | ApolloClient$ExecutionPatchIncrementalResult; +declare type ApolloClient$FetchResult< + TData = { [key: string]: any, ... }, + TContext = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } +> = ApolloClient$SingleExecutionResult | ApolloClient$ExecutionPatchResult; + +declare type ApolloClient$NextLink = (operation: ApolloClient$Operation) => ZenObservable$Observable>; +declare interface ApolloClient$GraphQLRequest { + query: GraphQL$DocumentNode; + variables?: Object; + operationName?: string; + context?: Object; + extensions?: Object; +} +declare type ApolloClient$RequestHandler = (operation: ApolloClient$Operation, forward: ApolloClient$NextLink) => ZenObservable$Observable> | null; + +// @apollo/client/link/core/ApolloLink.d.ts +// ApolloLink class is global so that multiple modules below can extend classes from it +declare class ApolloClient$ApolloLink { + static empty(): ApolloClient$ApolloLink; + static from(links: (ApolloClient$ApolloLink | ApolloClient$RequestHandler)[]): ApolloClient$ApolloLink; + static split( + test: (op: ApolloClient$Operation) => boolean, + left: ApolloClient$ApolloLink | ApolloClient$RequestHandler, + right?: ApolloClient$ApolloLink | ApolloClient$RequestHandler + ): ApolloClient$ApolloLink; + static execute(link: ApolloClient$ApolloLink, operation: ApolloClient$GraphQLRequest): ZenObservable$Observable>; + static concat(first: ApolloClient$ApolloLink | ApolloClient$RequestHandler, second: ApolloClient$ApolloLink | ApolloClient$RequestHandler): ApolloClient$ApolloLink; + constructor(request?: ApolloClient$RequestHandler): this; + split( + test: (op: ApolloClient$Operation) => boolean, + left: ApolloClient$ApolloLink | ApolloClient$RequestHandler, + right?: ApolloClient$ApolloLink | ApolloClient$RequestHandler + ): ApolloClient$ApolloLink; + concat(next: ApolloClient$ApolloLink | ApolloClient$RequestHandler): ApolloClient$ApolloLink; + request(operation: ApolloClient$Operation, forward?: ApolloClient$NextLink): ZenObservable$Observable> | null; + onError(error: any, observer?: ZenObservable$Observer>): false | void; + setOnError(fn: $PropertyType): this; +} + +declare module "@apollo/client" { + + // External Types + + // React + + import type { Component, ComponentType, Context, Node } from "react"; + + // ts-invariant + + declare class InvariantError extends Error { + framesToPop: number; + name: string; + constructor(message?: string | number): this; + } + + // import ... from "graphql"; + + declare type DirectiveNode = Object; + declare type FieldNode = Object; + declare type VariableNode = Object; + declare type InlineFragmentNode = Object; + declare type ValueNode = Object; + declare type SelectionNode = Object; + declare type NameNode = Object; + declare type SelectionSetNode = Object; + declare type Location = Object; + declare type DefinitionNode = Object; + declare type VariableDefinitionNode = Object; + declare type FragmentDefinitionNode = Object; + declare type ASTNode = Object; + declare function print(ast: ASTNode): string; + + // import { TypedDocumentNode } from "@graphql-typed-document-node/core"; + declare type TypedDocumentNode = {| + ...GraphQL$DocumentNode, + + /** + * This type is used to ensure that the variables you pass in to the query are assignable to Variables + * and that the Result is assignable to whatever you pass your result to. The method is never actually + * implemented, but the type is valid because we list it as optional + */ + __apiType?: (variables: Variables) => Result, + |}; + declare export type GraphQLSchema = Object; + + // import { Trie } from "@wry/trie"; + declare type Trie = Object; + + // @apollo/client/link/core/types + + declare export type Path = ApolloClient$Path; + declare export type Data = ApolloClient$Data; + declare export interface ExecutionPatchResultBase extends ApolloClient$ExecutionPatchResultBase {} + declare export type ExecutionPatchInitialResult = ApolloClient$ExecutionPatchInitialResult; + declare export interface IncrementalPayload extends ApolloClient$IncrementalPayload {} + declare export type ExecutionPatchIncrementalResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$ExecutionPatchIncrementalResult; + declare export type ExecutionPatchResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$ExecutionPatchResult; + declare export interface GraphQLRequest extends ApolloClient$GraphQLRequest {} + declare export interface Operation extends ApolloClient$Operation {} + declare export type SingleExecutionResult< + TData = { [key: string]: any, ... }, + TContext = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$SingleExecutionResult; + declare export type FetchResult< + TData = { [key: string]: any, ... }, + TContext = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$FetchResult; + declare export type NextLink = ApolloClient$NextLink; + declare export type RequestHandler = ApolloClient$RequestHandler; + + // @apollo/client/errors/index.d.ts + + declare export function isApolloError(err: Error): boolean; + declare export type GraphQLErrors = $ReadOnlyArray; + declare export type NetworkError = Error | ServerParseError | ServerError | null; + declare export class ApolloError mixins Error { + message: string; + graphQLErrors: GraphQLErrors; + clientErrors: $ReadOnlyArray; + networkError: Error | ServerParseError | ServerError | null; + extraInfo: any; + constructor(x: { + graphQLErrors?: $ReadOnlyArray, + clientErrors?: $ReadOnlyArray, + networkError?: Error | ServerParseError | ServerError | null, + errorMessage?: string, + extraInfo?: any, + ... + }): this; + } + + // @apollo/client/utilities/graphql/fragments.d.ts + + declare export function getFragmentQueryDocument(document: GraphQL$DocumentNode, fragmentName?: string): GraphQL$DocumentNode; + declare export interface FragmentMap { + [fragmentName: string]: FragmentDefinitionNode; + } + declare export type FragmentMapFunction = (fragmentName: string) => FragmentDefinitionNode | null; + declare export function createFragmentMap(fragments?: FragmentDefinitionNode[]): FragmentMap; + declare export function getFragmentFromSelection( + selection: SelectionNode, + fragmentMap?: FragmentMap | FragmentMapFunction + ): InlineFragmentNode | FragmentDefinitionNode | null; + + // @apollo/client/utilities/graphql/storeUtils.d.ts + + declare export interface Reference { + +__ref: string; + } + declare export function makeReference(id: string): Reference; + declare export function isReference(obj: any): boolean; + declare export type StoreValue = number | string | string[] | Reference | Reference[] | null | void | void | Object; + declare export interface StoreObject { + __typename?: string; + [storeFieldName: string]: StoreValue; + } + declare export function isGraphQL$DocumentNode(value: any): boolean; + declare export function valueToObjectRepresentation( + argObj: any, + name: NameNode, + value: ValueNode, + variables?: Object + ): void; + declare export function storeKeyNameFromField(field: FieldNode, variables?: Object): string; + declare export type Directives = { + [directiveName: string]: { + [argName: string]: any, + }, + }; + declare export var getStoreKeyName: (( + fieldName: string, + args?: { ... } | null, + directives?: Directives + ) => string) & {| + setStringify(s: typeof stringify): (value: any) => string, + |}; + declare export var stringify: (value: any) => string; + declare export function argumentsObjectFromField( + field: FieldNode | DirectiveNode, + variables?: { [key: string]: any, ... } + ): Object | null; + declare export function resultKeyNameFromField(field: FieldNode): string; + declare export function getTypenameFromResult( + result: { [key: string]: any, ... }, + selectionSet: SelectionSetNode, + fragmentMap?: FragmentMap + ): string | void; + declare export function isField(selection: SelectionNode): boolean; + declare export function isInlineFragment(selection: SelectionNode): boolean; + declare export type VariableValue = (node: VariableNode) => any; + + // @apollo/client/cache/core/types/Cache.d.ts + + declare type Cache$DiffResult = DataProxy$DiffResult; + declare type Cache$ReadQueryOptions = DataProxy$ReadQueryOptions; + declare type Cache$ReadFragmentOptions = DataProxy$ReadFragmentOptions; + declare type Cache$WriteQueryOptions = DataProxy$WriteQueryOptions; + declare type Cache$WriteFragmentOptions = DataProxy$WriteFragmentOptions; + declare type Cache$UpdateQueryOptions = DataProxy$UpdateQueryOptions; + declare type Cache$UpdateFragmentOptions = DataProxy$UpdateFragmentOptions; + + declare export var Cache: typeof npm$namespace$Cache; + + declare export var npm$namespace$Cache: {| + EvictOptions: Class, + ResetOptions: Class, + ModifyOptions: Class, + |}; + declare export type Cache$WatchCallback = ( + diff: Cache$DiffResult, + lastDiff?: Cache$DiffResult + ) => void; + + declare export type Cache$ReadOptions = { + rootId?: string, + previousResult?: any, + optimistic: boolean, + returnPartialData?: boolean, + canonizeResults?: boolean, + ... + } & DataProxy$Query; + + declare export type Cache$WriteOptions = { + dataId?: string, + result: TResult, + ... + } & $Diff, {| id: any |}> & + $Diff, {| data: any |}>; + + declare export type Cache$DiffOptions = { ... } & $Diff< + Cache$ReadOptions, + {| rootId: any |} + >; + + declare export type Cache$WatchOptions = { + watcher?: { [key: string]: any }, + immediate?: boolean, + callback: Cache$WatchCallback, + lastDiff?: Cache$DiffResult, + ... + } & Cache$DiffOptions; + + declare export interface Cache$EvictOptions { + id?: string; + fieldName?: string; + args?: { [key: string]: any, ... }; + broadcast?: boolean; + } + + declare export interface Cache$ResetOptions { + discardWatches?: boolean; + } + + declare export interface Cache$ModifyOptions { + id?: string; + fields: Modifiers | Modifier; + optimistic?: boolean; + broadcast?: boolean; + } + + declare export interface Cache$BatchOptions { + update(cache: TCache): TUpdateResult; + optimistic?: string | boolean; + removeOptimistic?: string; + onWatchUpdated?: ( + watch: Cache$WatchOptions<>, + diff: Cache$DiffResult, + lastDiff: Cache$DiffResult | void + ) => any; + } + + // @apollo/client/cache/inmemory/entityStore.d.ts + + declare export class EntityStore implements NormalizedCache { + +policies: Policies; + +group: CacheGroup; + data: NormalizedCacheObject; + constructor(policies: Policies, group: CacheGroup): this; + addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer; + removeLayer(layerId: string): EntityStore; + toObject(): NormalizedCacheObject; + has(dataId: string): boolean; + get(dataId: string, fieldName: string): StoreValue; + lookup(dataId: string, dependOnExistence?: boolean): StoreObject | void; + merge(older: string | StoreObject, newer: StoreObject | string): void; + modify(dataId: string, fields: Modifier | Modifiers): boolean; + delete(dataId: string, fieldName?: string, args?: { [key: string]: any, ... }): boolean; + evict(options: Cache$EvictOptions, limit: EntityStore): boolean; + clear(): void; + extract(): NormalizedCacheObject; + replace(newData: NormalizedCacheObject | null): void; + getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType; + retain(rootId: string): number; + release(rootId: string): number; + getRootIdSet(ids?: Set): Set; + gc(): string[]; + findChildRefIds(dataId: string): { [key: string]: true, ... }; + makeCacheKey(...args: any[]): { [key: string]: any }; + getFieldValue: (objectOrReference: StoreObject | Reference | void, storeFieldName: string) => SafeReadonly; + canRead: CanReadFunction; + toReference: ToReferenceFunction; + static Root: typeof EntityStore$Root; + } + + declare export class EntityStore$Root mixins EntityStore { + constructor(x: { + policies: Policies, + resultCaching?: boolean, + seed?: NormalizedCacheObject, + ... + }): EntityStore$Root; + +stump: Stump; + addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer; + removeLayer(): EntityStore$Root; + +storageTrie: Trie; + getStorage(): StorageType; + } + + declare export type FieldValueGetter = $PropertyType; + declare export class CacheGroup { + +caching: boolean; + keyMaker: Trie<{ [key: string]: any }>; + constructor(caching: boolean, parent?: CacheGroup | null): this; + resetCaching(): void; + depend(dataId: string, storeFieldName: string): void; + dirty(dataId: string, storeFieldName: string): void; + } + declare export function maybeDependOnExistenceOfEntity(store: NormalizedCache, entityId: string): void; + declare export class Layer mixins EntityStore { + +id: string; + +parent: EntityStore; + +replay: (layer: EntityStore) => any; + +group: CacheGroup; + constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup): this; + addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer; + removeLayer(layerId: string): EntityStore; + toObject(): NormalizedCacheObject; + findChildRefIds(dataId: string): { [key: string]: true, ... }; + getStorage(): StorageType; + } + declare export class Stump mixins Layer { + constructor(root: EntityStore$Root): this; + removeLayer(): EntityStore; + merge(): any; + } + declare export function supportsResultCaching(store: any): boolean; + + // @apollo/client/cache/inmemory/fragmentRegistry.d.ts + + declare export interface FragmentRegistryAPI { + register(...fragments: GraphQL$DocumentNode[]): FragmentRegistryAPI; + lookup(fragmentName: string): FragmentDefinitionNode | null; + transform(document: D): D; + } + declare export function createFragmentRegistry(...fragments: GraphQL$DocumentNode[]): FragmentRegistryAPI; + + // @apollo/client/cache/inmemory/types.d.ts + + declare export type IdGetterObj = { + __typename?: string, + id?: string, + _id?: string, + ... + } & Object; + declare export type IdGetter = (value: IdGetterObj) => string | void; + declare export interface NormalizedCache { + has(dataId: string): boolean; + get(dataId: string, fieldName: string): StoreValue; + merge(olderId: string, newerObject: StoreObject): void; + merge(olderObject: StoreObject, newerId: string): void; + modify(dataId: string, fields: Modifiers | Modifier): boolean; + delete(dataId: string, fieldName?: string): boolean; + clear(): void; + toObject(): NormalizedCacheObject; + replace(newData: NormalizedCacheObject): void; + retain(rootId: string): number; + release(rootId: string): number; + getFieldValue: FieldValueGetter; + toReference: ToReferenceFunction; + canRead: CanReadFunction; + getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType; + } + declare export interface NormalizedCacheObject { + __META?: { + extraRootIds: string[], + ... + }; + [dataId: string]: StoreObject | void; + } + declare export type OptimisticStoreItem = { + id: string, + data: NormalizedCacheObject, + transaction: Transaction, + ... + }; + declare export type ReadQueryOptions = { + store: NormalizedCache, + query: GraphQL$DocumentNode, + variables?: Object, + previousResult?: any, + canonizeResults?: boolean, + rootId?: string, + config?: ApolloReducerConfig, + ... + }; + declare export type DiffQueryAgainstStoreOptions = { + ...ReadQueryOptions, + returnPartialData?: boolean, + ... + }; + declare export type ApolloReducerConfig = { + dataIdFromObject?: KeyFieldsFunction, + addTypename?: boolean, + ... + }; + declare export type InMemoryCacheConfig = { + resultCaching?: boolean, + possibleTypes?: PossibleTypesMap, + typePolicies?: TypePolicies, + resultCacheMaxSize?: number, + canonizeResults?: boolean, + fragments?: FragmentRegistryAPI, + ... + } & ApolloReducerConfig; + declare export interface MergeInfo { + field: FieldNode; + typename: string | void; + merge: FieldMergeFunction<>; + } + declare export interface MergeTree { + info?: MergeInfo; + map: Map; + } + declare export interface ReadMergeModifyContext { + store: NormalizedCache; + variables?: { [key: string]: any, ... }; + varString?: string; + } + + // @apollo/client/cache/inmemory/reactiveVars.d.ts + + declare export interface ReactiveVar { + (newValue?: T): T; + onNextChange(listener: ReactiveListener): () => void; + attachCache(cache: ApolloCache): ReactiveVar; + forgetCache(cache: ApolloCache): boolean; + } + declare export type ReactiveListener = (value: T) => any; + declare export var cacheSlot: { + +id: string, + hasValue(): boolean, + getValue(): ApolloCache | void, + withValue( + value: ApolloCache, + callback: (...args: TArgs) => TResult, + args?: TArgs | void, + thisArg?: TThis | void + ): TResult, + ... + }; + declare export function forgetCache(cache: ApolloCache): void; + declare export function recallCache(cache: ApolloCache): void; + declare export function makeVar(value: T): ReactiveVar; + + // @apollo/client/cache/inmemory/inMemoryCache.d.ts + + declare export type BroadcastOptions = {| + optimistic?: string | boolean; + onWatchUpdated?: ( + watch: Cache$WatchOptions<>, + diff: Cache$DiffResult, + lastDiff: Cache$DiffResult | void + ) => any; + |}; + declare export class InMemoryCache mixins ApolloCache { + config: InMemoryCacheConfig; + +policies: Policies; + +makeVar: typeof makeVar; + constructor(config?: InMemoryCacheConfig): this; + restore(data: NormalizedCacheObject): this; + extract(optimistic?: boolean): NormalizedCacheObject; + read(options: Cache$ReadOptions): TData | null; + write(write: Cache$WriteOptions): Reference | void; + modify(options: Cache$ModifyOptions): boolean; + diff(options: Cache$DiffOptions): Cache$DiffResult; + watch(watch: Cache$WatchOptions): () => void; + gc(options?: { + resetResultCache?: boolean, + resetResultIdentities?: boolean, + ... + }): string[]; + retain(rootId: string, optimistic?: boolean): number; + release(rootId: string, optimistic?: boolean): number; + identify(object: StoreObject | Reference): string | void; + evict(options: Cache$EvictOptions): boolean; + reset(options?: Cache$ResetOptions): Promise; + removeOptimistic(idToRemove: string): void; + batch(options: Cache$BatchOptions, TUpdateResult>): TUpdateResult; + performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any; + transformDocument(document: GraphQL$DocumentNode): GraphQL$DocumentNode; + transformForLink(document: GraphQL$DocumentNode): GraphQL$DocumentNode; + broadcastWatches(options?: BroadcastOptions): void; + } + + // @apollo/client/cache/inmemory/object-canon.d.ts + + declare export class ObjectCanon { + isKnown(value: any): boolean; + pass(value: T): T; + admit(value: T): T; + +empty: { ... }; + } + declare export var canonicalStringify: ((value: any) => string) & {| + reset: typeof resetCanonicalStringify, + |}; + declare export function resetCanonicalStringify(): void; + + // @apollo/client/cache/inmemory/readFromStore.d.ts + + declare export type VariableMap = { + [name: string]: any, + }; + declare export type ExecResult = { + result: R, + missing?: MissingTree, + ... + }; + declare export interface StoreReaderConfig { + cache: InMemoryCache; + addTypename?: boolean; + resultCacheMaxSize?: number; + canonizeResults?: boolean; + canon?: ObjectCanon; + fragments?: $PropertyType; + } + declare export class StoreReader { + canon: ObjectCanon; + resetCanon(): void; + constructor(config: StoreReaderConfig): this; + diffQueryAgainstStore(x: DiffQueryAgainstStoreOptions): Cache$DiffResult; + isFresh( + result: { [key: string]: any, ... }, + parent: StoreObject | Reference, + selectionSet: SelectionSetNode, + context: ReadMergeModifyContext + ): boolean; + } + + // @apollo/client/cache/inmemory/writeToStore.d.ts + + declare export type WriteContext = { + +written: { + [dataId: string]: SelectionSetNode[], + }, + +fragmentMap: FragmentMap, + lookupFragment: FragmentMapFunction, + merge(existing: T, incoming: T): T, + overwrite: boolean, + incomingById: Map< + string, + { + storeObject: StoreObject, + mergeTree?: MergeTree, + fieldNodeSet: Set, + ... + } + >, + clientOnly: boolean, + deferred: boolean, + flavors: Map, + ... + } & ReadMergeModifyContext; + declare export type FlavorableWriteContext = {| + clientOnly: boolean, + deferred: boolean, + flavors: Map, + |} + declare export interface WriteOptions + // extends $Diff, {| id: any |}>, $Diff, {| data: any |}> + { + dataId?: string; + result: TResult; + } + declare export class StoreWriter { + +cache: InMemoryCache; + constructor( + cache: InMemoryCache, + reader?: StoreReader | void, + fragments?: FragmentRegistryAPI | void + ): this; + writeToStore(store: NormalizedCache, x: WriteOptions<>): Reference | void; + } + + // @apollo/client/cache/inmemory/policies.d.ts + + declare export type TypePolicies = { + [__typename: string]: TypePolicy, + }; + declare export type KeySpecifier = $ReadOnlyArray; + declare export type KeyFieldsContext = { + typename: string | void, + storeObject: StoreObject, + readField: ReadFieldFunction, + selectionSet?: SelectionSetNode, + fragmentMap?: FragmentMap, + keyObject?: { [key: string]: any, ... }, + ... + }; + declare export type KeyFieldsFunction = ( + object: $ReadOnly, + context: KeyFieldsContext + ) => KeySpecifier | false | $Call<((...args: any[]) => R) => R, IdGetter>; + declare export type TypePolicy = { + keyFields?: KeySpecifier | KeyFieldsFunction | false, + merge?: FieldMergeFunction<> | boolean, + queryType?: true, + mutationType?: true, + subscriptionType?: true, + fields?: { + [fieldName: string]: FieldPolicy | FieldReadFunction, + }, + ... + }; + declare export type KeyArgsFunction = ( + args: { [key: string]: any, ... } | null, + context: { + typename: string, + fieldName: string, + field: FieldNode | null, + variables?: { [key: string]: any, ... }, + ... + } + ) => KeySpecifier | false | $Call<((...args: any[]) => R) => R, IdGetter>; + declare export type FieldPolicy< + TExisting = any, + TIncoming = TExisting, + TReadResult = TIncoming, + TOptions: FieldFunctionOptions<> = FieldFunctionOptions<> + > = { + keyArgs?: KeySpecifier | KeyArgsFunction | false, + read?: FieldReadFunction, + merge?: FieldMergeFunction | boolean, + ... + }; + declare export type StorageType = { [key: string]: any, ... }; + declare export interface FieldFunctionOptions< + TArgs = { [key: string]: any, ... }, + TVars = { [key: string]: any, ... } + > { + args: TArgs | null; + fieldName: string; + storeFieldName: string; + field: FieldNode | null; + variables?: TVars; + isReference: typeof isReference; + toReference: ToReferenceFunction; + storage: StorageType; + cache: InMemoryCache; + readField: ReadFieldFunction; + canRead: CanReadFunction; + mergeObjects: MergeObjectsFunction; + } + declare export type MergeObjectsFunction = (existing: T, incoming: T) => T; + declare export type FieldReadFunction< + TExisting = any, + TReadResult = TExisting, + TOptions: FieldFunctionOptions<> = FieldFunctionOptions<> + > = (existing: SafeReadonly | void, options: TOptions) => TReadResult | void; + declare export type FieldMergeFunction< + TExisting = any, + TIncoming = TExisting, + TOptions: FieldFunctionOptions<> = FieldFunctionOptions<> + > = ( + existing: SafeReadonly | void, + incoming: SafeReadonly, + options: TOptions + ) => SafeReadonly; + declare export type PossibleTypesMap = { + [supertype: string]: string[], + }; + declare export class Policies { + +cache: InMemoryCache; + +rootIdsByTypename: { [key: string]: string, ... }; + +rootTypenamesById: { [key: string]: string, ... }; + +usingPossibleTypes: false; + constructor(config: { + cache: InMemoryCache, + dataIdFromObject?: KeyFieldsFunction, + possibleTypes?: PossibleTypesMap, + typePolicies?: TypePolicies, + ... + }): this; + identify( + object: StoreObject, + partialContext?: $Rest + ): [string | void, StoreObject | void]; + addTypePolicies(typePolicies: TypePolicies): void; + addPossibleTypes(possibleTypes: PossibleTypesMap): void; + fragmentMatches( + fragment: InlineFragmentNode | FragmentDefinitionNode, + typename: string | void, + result?: { [key: string]: any, ... }, + variables?: { [key: string]: any, ... } + ): boolean; + hasKeyArgs(typename: string | void, fieldName: string): boolean; + getStoreFieldName(fieldSpec: FieldSpecifier): string; + readField(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly | void; + getReadFunction(typename: string | void, fieldName: string): FieldReadFunction<> | void; + getMergeFunction( + parentTypename: string | void, + fieldName: string, + childTypename: string | void + ): FieldMergeFunction<> | void; + runMergeFunction( + existing: StoreValue, + incoming: StoreValue, + x: MergeInfo, + context: WriteContext, + storage?: StorageType + ): any; + } + declare export function normalizeReadFieldOptions( + readFieldArgs: TypeScript$IArguments, + objectOrReference: StoreObject | Reference | void, + variables?: $PropertyType + ): ReadFieldOptions; + + // @apollo/client/cache/core/types/common.d.ts + + // see https://gist.github.com/thecotne/6e5969f4aaf8f253985ed36b30ac9fe0 + declare export type $FlowGen$If = $Call< + ((true, Then, Else) => Then) & ((false, Then, Else) => Else), + X, + Then, + Else + >; + + declare export type $FlowGen$Assignable = $Call<((...r: [B]) => true) & ((...r: [A]) => false), A>; + + declare export type SafeReadonly = $FlowGen$If<$FlowGen$Assignable, $ReadOnly, T>; + declare export type MissingTree = + | string + | { + [key: string]: MissingTree, + }; + declare export class MissingFieldError mixins Error { + +path: MissingTree | Array; + +query: GraphQL$DocumentNode; + +variables?: { [key: string]: any, ... } | void; + constructor( + message: string, + path: MissingTree | Array, + query: GraphQL$DocumentNode, + variables?: { [key: string]: any, ... } | void + ): this; + +missing: MissingTree; + } + declare export interface FieldSpecifier { + typename?: string; + fieldName: string; + field?: FieldNode; + args?: { [key: string]: any, ... }; + variables?: { [key: string]: any, ... }; + } + declare export type ReadFieldOptions = { + from?: StoreObject | Reference, + ... + } & FieldSpecifier; + declare export interface ReadFieldFunction { + (options: ReadFieldOptions): SafeReadonly | void; + (fieldName: string, from?: StoreObject | Reference): SafeReadonly | void; + } + declare export type ToReferenceFunction = ( + objOrIdOrRef: StoreObject | string | Reference, + mergeIntoStore?: boolean + ) => Reference | void; + declare export type CanReadFunction = (value: StoreValue) => boolean; + declare export type Modifier = ( + value: T, + details: { + DELETE: any, + INVALIDATE: any, + fieldName: string, + storeFieldName: string, + readField: ReadFieldFunction, + canRead: CanReadFunction, + isReference: typeof isReference, + toReference: ToReferenceFunction, + storage: StorageType, + ... + } + ) => T; + declare export type Modifiers = { + [fieldName: string]: Modifier, + }; + + // @apollo/client/cache/core/types/DataProxy.d.ts + + declare export interface DataProxy$Fragment { + id?: string; + fragment: GraphQL$DocumentNode | TypedDocumentNode; + fragmentName?: string; + variables?: TVariables; + } + + declare export type DataProxy$ReadQueryOptions = { + returnPartialData?: boolean, + optimistic?: boolean, + canonizeResults?: boolean, + ... + } & DataProxy$Query; + + declare export type DataProxy$ReadFragmentOptions = { + returnPartialData?: boolean, + optimistic?: boolean, + canonizeResults?: boolean, + ... + } & DataProxy$Fragment; + + declare export interface DataProxy$WriteOptions { + data: TData; + broadcast?: boolean; + overwrite?: boolean; + } + + declare export type DataProxy$WriteQueryOptions = { ... } & DataProxy$Query & + DataProxy$WriteOptions; + + declare export type DataProxy$WriteFragmentOptions = { ... } & DataProxy$Fragment< + TVariables, + TData + > & + DataProxy$WriteOptions; + + declare export type DataProxy$UpdateQueryOptions = { ... } & $Diff< + {| + ...DataProxy$ReadQueryOptions, + ...DataProxy$WriteQueryOptions, + |}, + {| data: any |} + >; + + declare export type DataProxy$UpdateFragmentOptions = { ... } & $Diff< + {| + ...DataProxy$ReadFragmentOptions, + ...DataProxy$WriteFragmentOptions, + |}, + {| data: any |} + >; + + declare export type DataProxy$DiffResult = { + result?: T, + complete?: boolean, + missing?: MissingFieldError[], + fromOptimisticTransaction?: boolean, + ... + }; + + declare export interface DataProxy$Query { + query: GraphQL$DocumentNode | TypedDocumentNode; + variables?: TVariables; + id?: string; + } + declare export interface DataProxy { + readQuery( + options: DataProxy$ReadQueryOptions, + optimistic?: boolean + ): QueryType | null; + readFragment( + options: DataProxy$ReadFragmentOptions, + optimistic?: boolean + ): FragmentType | null; + writeQuery(x: Cache$WriteQueryOptions): Reference | void; + writeFragment(x: Cache$WriteFragmentOptions): Reference | void; + } + + // @apollo/client/cache/core/cache.d.ts + + declare export type Transaction = (c: ApolloCache) => void; + declare export class ApolloCache implements DataProxy { + read(query: Cache$ReadOptions): TData | null; + write(write: Cache$WriteOptions): Reference | void; + diff(options: Cache$DiffOptions): Cache$DiffResult; + watch(watch: Cache$WatchOptions): () => void; + reset(options?: Cache$ResetOptions): Promise; + evict(options: Cache$EvictOptions): boolean; + restore(serializedState: TSerialized): ApolloCache; + extract(optimistic?: boolean): TSerialized; + removeOptimistic(id: string): void; + batch(options: Cache$BatchOptions, U>): U; + performTransaction(transaction: Transaction, optimisticId?: string | null): void; + recordOptimisticTransaction(transaction: Transaction, optimisticId: string): void; + transformDocument(document: GraphQL$DocumentNode): GraphQL$DocumentNode; + transformForLink(document: GraphQL$DocumentNode): GraphQL$DocumentNode; + identify(object: StoreObject | Reference): string | void; + gc(): string[]; + modify(options: Cache$ModifyOptions): boolean; + readQuery( + options: DataProxy$ReadQueryOptions, + optimistic?: boolean + ): QueryType | null; + readFragment( + options: DataProxy$ReadFragmentOptions, + optimistic?: boolean + ): FragmentType | null; + writeQuery(x: Cache$WriteQueryOptions): Reference | void; + writeFragment(x: Cache$WriteFragmentOptions): Reference | void; + updateQuery( + options: Cache$UpdateQueryOptions, + update: (data: TData | null) => TData | null | void + ): TData | null; + updateFragment( + options: Cache$UpdateFragmentOptions, + update: (data: TData | null) => TData | null | void + ): TData | null; + } + + // @apollo/client/core/QueryInfo.d.ts + + declare export type QueryStoreValue = {| + variables?: { [key: string]: any, ... }; + networkStatus?: $Values; + networkError?: Error | null; + graphQLErrors?: $ReadOnlyArray; + |}; + declare export var CacheWriteBehavior: {| + +FORBID: 0, + +OVERWRITE: 1, + +MERGE: 2, + |}; + declare export class QueryInfo { + +queryId: string; + listeners: Set; + document: GraphQL$DocumentNode | null; + lastRequestId: number; + subscriptions: Set; + variables?: { [key: string]: any, ... }; + networkStatus?: $Values; + networkError?: Error | null; + graphQLErrors?: $ReadOnlyArray; + stopped: boolean; + constructor(queryManager: QueryManager, queryId?: string): this; + init(query: { + document: GraphQL$DocumentNode, + variables: { [key: string]: any, ... } | void, + networkStatus?: $Values, + observableQuery?: ObservableQuery, + lastRequestId?: number, + ... + }): this; + reset(): void; + getDiff(variables?: { [key: string]: any, ... } | void): Cache$DiffResult; + setDiff(diff: Cache$DiffResult | null): void; + +observableQuery: ObservableQuery | null; + setObservableQuery(oq: ObservableQuery | null): void; + notify(): void; + stop(): void; + resetLastWrite(): void; + markResult( + result: ApolloClient$FetchResult, + document: GraphQL$DocumentNode, + options: {| + fetchPolicy?: WatchQueryFetchPolicy; + variables?: OperationVariables; + errorPolicy?: ErrorPolicy; + |}, + cacheWriteBehavior: $Values + ): void; + markReady(): $Values; + markError(error: ApolloError): ApolloError; + } + declare export function shouldWriteResult(result: ApolloClient$FetchResult, errorPolicy?: ErrorPolicy): boolean; + + declare export class ApolloLink extends ApolloClient$ApolloLink {} + + // @apollo/client/utilities/observables/Concast.d.ts + + declare export type MaybeAsync = T | Promise; + declare export type Source = MaybeAsync>; + declare export type ConcastSourcesIterable = Iterable>; + declare export type ConcastSourcesArray = Array>; + declare export class Concast mixins ZenObservable$Observable { + constructor(sources: MaybeAsync> | ZenObservable$Subscriber): this; + addObserver(observer: ZenObservable$Observer): void; + removeObserver(observer: ZenObservable$Observer): void; + +promise: Promise; + beforeNext(callback: NextResultListener): void; + cancel: (reason: any) => void; + } + declare export type NextResultListener = (method: "next" | "error" | "complete", arg?: any) => any; + + // @apollo/client/core/watchQueryOptions.d.ts + + declare export type FetchPolicy = "cache-first" | "network-only" | "cache-only" | "no-cache" | "standby"; + declare export type WatchQueryFetchPolicy = FetchPolicy | "cache-and-network"; + declare export type MutationFetchPolicy = "network-only" | "no-cache"; + declare export type RefetchWritePolicy = "merge" | "overwrite"; + declare export type ErrorPolicy = "none" | "ignore" | "all"; + declare export interface QueryOptions { + query: GraphQL$DocumentNode | TypedDocumentNode; + variables?: TVariables; + errorPolicy?: ErrorPolicy; + context?: any; + fetchPolicy?: FetchPolicy; + pollInterval?: number; + notifyOnNetworkStatusChange?: boolean; + returnPartialData?: boolean; + partialRefetch?: boolean; + canonizeResults?: boolean; + } + declare export type WatchQueryOptions = { + fetchPolicy?: WatchQueryFetchPolicy, + nextFetchPolicy?: + | WatchQueryFetchPolicy + | (( + currentFetchPolicy: WatchQueryFetchPolicy, + context: NextFetchPolicyContext + ) => WatchQueryFetchPolicy), + initialFetchPolicy?: WatchQueryFetchPolicy, + refetchWritePolicy?: RefetchWritePolicy, + ... + } & $Diff, {| fetchPolicy: any |}>; + declare export interface NextFetchPolicyContext { + reason: "after-fetch" | "variables-changed"; + observable: ObservableQuery; + options: WatchQueryOptions; + initialFetchPolicy: WatchQueryFetchPolicy; + } + declare export type FetchMoreQueryOptions = {| + query?: GraphQL$DocumentNode | TypedDocumentNode, + variables?: $Rest, + context?: any + |}; + declare export type UpdateQueryFn< + TData = any, + TSubscriptionVariables = OperationVariables, + TSubscriptionData = TData + > = ( + previousQueryResult: TData, + options: { + subscriptionData: { + data: TSubscriptionData, + ... + }, + variables?: TSubscriptionVariables, + ... + } + ) => TData; + declare export type SubscribeToMoreOptions< + TData = any, + TSubscriptionVariables = OperationVariables, + TSubscriptionData = TData + > = { + document: GraphQL$DocumentNode | TypedDocumentNode, + variables?: TSubscriptionVariables, + updateQuery?: UpdateQueryFn, + onError?: (error: Error) => void, + context?: DefaultContext, + ... + }; + declare export interface SubscriptionOptions { + query: GraphQL$DocumentNode | TypedDocumentNode; + variables?: TVariables; + fetchPolicy?: FetchPolicy; + errorPolicy?: ErrorPolicy; + context?: DefaultContext; + } + declare export interface MutationBaseOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > { + optimisticResponse?: TData | ((vars: TVariables) => TData); + updateQueries?: MutationQueryReducersMap; + refetchQueries?: ((result: ApolloClient$FetchResult) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude; + awaitRefetchQueries?: boolean; + update?: MutationUpdaterFunction; + onQueryUpdated?: OnQueryUpdated; + errorPolicy?: ErrorPolicy; + variables?: TVariables; + context?: TContext; + } + declare export type MutationOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = { + mutation: GraphQL$DocumentNode | TypedDocumentNode, + fetchPolicy?: MutationFetchPolicy, + keepRootFields?: boolean, + ... + } & MutationBaseOptions; + + // @apollo/client/core/networkStatus.d.ts + + declare export var NetworkStatus: {| + +loading: 1, + +setVariables: 2, + +fetchMore: 3, + +refetch: 4, + +poll: 6, + +ready: 7, + +error: 8, + |}; + declare export function isNetworkRequestInFlight(networkStatus?: $Values): boolean; + + // @apollo/client/core/LocalState.d.ts + + declare export type Resolver = ( + rootValue?: any, + args?: any, + context?: any, + info?: { + field: FieldNode, + fragmentMap: FragmentMap, + ... + } + ) => any; + declare export type FragmentMatcher = (rootValue: any, typeCondition: string, context: any) => boolean; + declare export type ExecContext = { + fragmentMap: FragmentMap, + context: any, + variables: VariableMap, + fragmentMatcher: FragmentMatcher, + defaultOperationType: string, + exportedVariables: { [key: string]: any, ... }, + onlyRunForcedResolvers: boolean, + ... + }; + declare export type LocalStateOptions = { + cache: ApolloCache, + client?: ApolloClient, + resolvers?: Resolvers | Resolvers[], + fragmentMatcher?: FragmentMatcher, + ... + }; + declare export class LocalState { + constructor(x: LocalStateOptions): this; + addResolvers(resolvers: Resolvers | Resolvers[]): void; + setResolvers(resolvers: Resolvers | Resolvers[]): void; + getResolvers(): Resolvers; + runResolvers(x: { + document: GraphQL$DocumentNode | null, + remoteResult: ApolloClient$FetchResult, + context?: { [key: string]: any, ... }, + variables?: { [key: string]: any, ... }, + onlyRunForcedResolvers?: boolean, + ... + }): Promise>; + setFragmentMatcher(fragmentMatcher: FragmentMatcher): void; + getFragmentMatcher(): FragmentMatcher; + clientQuery(document: GraphQL$DocumentNode): GraphQL$DocumentNode | null; + serverQuery(document: GraphQL$DocumentNode): GraphQL$DocumentNode | null; + prepareContext(context?: { [key: string]: any, ... }): { + cache: ApolloCache, + getCacheKey(obj: StoreObject): string | void, + ... + }; + addExportedVariables( + document: GraphQL$DocumentNode, + variables?: OperationVariables, + context?: { ... } + ): Promise<{ + [x: string]: any, + }>; + shouldForceResolvers(document: ASTNode): boolean; + } + + // @apollo/client/core/QueryManager.d.ts + + declare export interface MutationStoreValue { + mutation: GraphQL$DocumentNode; + variables: { [key: string]: any, ... }; + loading: boolean; + error: Error | null; + } + declare export type UpdateQueries = $PropertyType, "updateQueries">; + declare export interface TransformCacheEntry { + document: GraphQL$DocumentNode; + hasClientExports: boolean; + hasForcedResolvers: boolean; + clientQuery: GraphQL$DocumentNode | null; + serverQuery: GraphQL$DocumentNode | null; + defaultVars: OperationVariables; + asQuery: GraphQL$DocumentNode; + } + declare export class QueryManager { + cache: ApolloCache; + link: ApolloClient$ApolloLink; + defaultOptions: DefaultOptions; + +assumeImmutableResults: boolean; + +ssrMode: boolean; + mutationStore?: { + [mutationId: string]: MutationStoreValue, + }; + constructor(x: { + cache: ApolloCache, + link: ApolloClient$ApolloLink, + defaultOptions?: DefaultOptions, + queryDeduplication?: boolean, + onBroadcast?: () => void, + ssrMode?: boolean, + clientAwareness?: { [key: string]: string, ... }, + localState?: LocalState, + assumeImmutableResults?: boolean, + ... + }): this; + stop(): void; + mutate>( + x: MutationOptions + ): Promise>; + markMutationResult>( + mutation: { + mutationId: string, + result: ApolloClient$FetchResult, + document: GraphQL$DocumentNode, + variables?: TVariables, + fetchPolicy?: MutationFetchPolicy, + errorPolicy: ErrorPolicy, + context?: TContext, + updateQueries: UpdateQueries, + update?: MutationUpdaterFunction, + awaitRefetchQueries?: boolean, + refetchQueries?: InternalRefetchQueriesInclude, + removeOptimistic?: string, + onQueryUpdated?: OnQueryUpdated, + keepRootFields?: boolean, + ... + }, + cache?: ApolloCache + ): Promise>; + markMutationOptimistic>( + optimisticResponse: any, + mutation: { + mutationId: string, + document: GraphQL$DocumentNode, + variables?: TVariables, + fetchPolicy?: MutationFetchPolicy, + errorPolicy: ErrorPolicy, + context?: TContext, + updateQueries: UpdateQueries, + update?: MutationUpdaterFunction, + keepRootFields?: boolean, + ... + } + ): void; + fetchQuery( + queryId: string, + options: WatchQueryOptions, + networkStatus?: $Values + ): Promise>; + getQueryStore(): { [key: string]: QueryStoreValue, ... }; + resetErrors(queryId: string): void; + transform(document: GraphQL$DocumentNode): TransformCacheEntry; + watchQuery(options: WatchQueryOptions): ObservableQuery; + query(options: QueryOptions, queryId?: string): Promise>; + generateQueryId(): string; + generateRequestId(): number; + generateMutationId(): string; + stopQueryInStore(queryId: string): void; + clearStore(options?: Cache.ResetOptions): Promise; + getObservableQueries( + include?: InternalRefetchQueriesInclude + ): Map>; + reFetchObservableQueries(includeStandby?: boolean): Promise[]>; + setObservableQuery(observableQuery: ObservableQuery): void; + startGraphQLSubscription(x: SubscriptionOptions<>): ZenObservable$Observable>; + stopQuery(queryId: string): void; + removeQuery(queryId: string): void; + broadcastQueries(): void; + getLocalState(): LocalState; + fetchQueryObservable( + queryId: string, + options: WatchQueryOptions, + networkStatus?: $Values + ): Concast>; + refetchQueries( + x: InternalRefetchQueriesOptions, TResult> + ): InternalRefetchQueriesMap; + } + + // @apollo/client/core/ObservableQuery.d.ts + + declare export interface FetchMoreOptions { + updateQuery?: ( + previousQueryResult: TData, + options: { + fetchMoreResult?: TData, + variables?: TVariables, + ... + } + ) => TData; + } + declare export interface UpdateQueryOptions { + variables?: TVariables; + } + declare export class ObservableQuery + mixins ZenObservable$Observable> { + +options: WatchQueryOptions; + +queryId: string; + +queryName?: string; + query: TypedDocumentNode; + variables: TVariables | void; + constructor(x: { + queryManager: QueryManager, + queryInfo: QueryInfo, + options: WatchQueryOptions, + ... + }): this; + result(): Promise>; + getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult; + isDifferentFromLastResult(newResult: ApolloQueryResult, variables?: TVariables): boolean | void; + getLastResult(variablesMustMatch?: boolean): ApolloQueryResult | void; + getLastError(variablesMustMatch?: boolean): ApolloError | void; + resetLastResults(): void; + resetQueryStoreErrors(): void; + refetch(variables?: $Rest): Promise>; + fetchMore(fetchMoreOptions: { + ...FetchMoreQueryOptions, + updateQuery?: ( + previousQueryResult: TData, + options: { + fetchMoreResult: TFetchData, + variables: TFetchVars, + ... + } + ) => TData, + ... + }): Promise>; + subscribeToMore( + options: SubscribeToMoreOptions + ): () => void; + setOptions(newOptions: $Rest, { ... }>): Promise>; + setVariables(variables: TVariables): Promise | void>; + updateQuery( + mapFn: (previousQueryResult: TData, options: OperationVariables) => TData + ): void; + startPolling(pollInterval: number): void; + stopPolling(): void; + reobserve( + newOptions?: $Rest, { ... }>, + newNetworkStatus?: $Values + ): Promise>; + hasObservers(): boolean; + } + declare export function reobserveCacheFirst( + obsQuery: ObservableQuery + ): Promise>; + declare export function logMissingFieldErrors(missing: MissingFieldError[] | MissingTree | void): void; + + // @apollo/client/core/types.d.ts + + declare export type DefaultContext = { [key: string]: any, ... }; + declare export type QueryListener = (queryInfo: QueryInfo) => void; + declare export type OnQueryUpdated = ( + observableQuery: ObservableQuery, + diff: Cache$DiffResult, + lastDiff: Cache$DiffResult | void + ) => boolean | TResult; + declare export type RefetchQueryDescriptor = string | GraphQL$DocumentNode; + declare export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions<>; + declare export type RefetchQueriesIncludeShorthand = "all" | "active"; + declare export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand; + declare export type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand; + declare export interface RefetchQueriesOptions, TResult> { + updateCache?: (cache: TCache) => void; + include?: RefetchQueriesInclude; + optimistic?: boolean; + onQueryUpdated?: OnQueryUpdated | null; + } + // export declare type RefetchQueriesPromiseResults = IsStrictlyAny extends true ? any[] : TResult extends boolean ? ApolloQueryResult[] : TResult extends PromiseLike ? U[] : TResult[]; + declare export type RefetchQueriesPromiseResults = TResult[]; + declare export type RefetchQueriesResult = { + queries: ObservableQuery[], + results: InternalRefetchQueriesResult[], + ... + } & Promise; + declare export type InternalRefetchQueriesOptions, TResult> = { + include?: InternalRefetchQueriesInclude, + removeOptimistic?: string, + ... + } & $Diff, {| include: any |}>; + declare export type InternalRefetchQueriesResult = $FlowGen$If< + $FlowGen$Assignable, + Promise>, + TResult + >; + declare export type InternalRefetchQueriesMap = Map< + ObservableQuery, + InternalRefetchQueriesResult + >; + declare export type OperationVariables = { [key: string]: any, ... }; + declare export type ApolloQueryResult = { + data: T, + errors?: $ReadOnlyArray, + error?: ApolloError, + loading: boolean, + networkStatus: $Values, + partial?: boolean, + ... + }; + declare export type MutationQueryReducer = ( + previousResult: { [key: string]: any, ... }, + options: { + mutationResult: ApolloClient$FetchResult, + queryName: string | void, + queryVariables: { [key: string]: any, ... }, + ... + } + ) => { [key: string]: any, ... }; + declare export type MutationQueryReducersMap< + T = { + [key: string]: any, + } + > = { + [queryName: string]: MutationQueryReducer, + }; + declare export type MutationUpdaterFn< + T = { + [key: string]: any, + } + > = (cache: ApolloCache, mutationResult: ApolloClient$FetchResult) => void; + declare export type MutationUpdaterFunction> = ( + cache: TCache, + result: $Diff, {| context: any |}>, + options: { + context?: TContext, + variables?: TVariables, + ... + } + ) => void; + declare export interface Resolvers { + [key: string]: { + [field: string]: Resolver, + }; + } + + // @apollo/client/core/ApolloClient.d.ts + + declare export interface DefaultOptions { + watchQuery?: $Rest, { ... }>; + query?: $Rest, { ... }>; + mutate?: $Rest, { ... }>; + } + declare export type ApolloClientOptions = { + uri?: string | UriFunction, + credentials?: string, + headers?: { [key: string]: string, ... }, + link?: ApolloClient$ApolloLink, + cache: ApolloCache, + ssrForceFetchDelay?: number, + ssrMode?: boolean, + connectToDevTools?: boolean, + queryDeduplication?: boolean, + defaultOptions?: DefaultOptions, + assumeImmutableResults?: boolean, + resolvers?: Resolvers | Resolvers[], + typeDefs?: string | string[] | GraphQL$DocumentNode | GraphQL$DocumentNode[], + fragmentMatcher?: FragmentMatcher, + name?: string, + version?: string, + ... + }; + declare export class ApolloClient implements DataProxy { + link: ApolloClient$ApolloLink; + cache: ApolloCache; + disableNetworkFetches: boolean; + version: string; + queryDeduplication: boolean; + defaultOptions: DefaultOptions; + +typeDefs: $PropertyType, "typeDefs">; + constructor(options: ApolloClientOptions): this; + stop(): void; + watchQuery(options: WatchQueryOptions): ObservableQuery; + query(options: QueryOptions): Promise>; + mutate< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + >( + options: MutationOptions + ): Promise>; + subscribe(options: SubscriptionOptions): ZenObservable$Observable>; + readQuery(options: DataProxy$ReadQueryOptions, optimistic?: boolean): QueryType | null; + readFragment(options: DataProxy$ReadFragmentOptions, optimistic?: boolean): TData | null; + writeQuery(options: Cache$WriteQueryOptions): void; + writeFragment(options: Cache$WriteFragmentOptions): void; + __actionHookForDevTools(cb: () => any): void; + __requestRaw(payload: ApolloClient$GraphQLRequest): ZenObservable$Observable>; + resetStore(): Promise[] | null>; + clearStore(): Promise; + onResetStore(cb: () => Promise): () => void; + onClearStore(cb: () => Promise): () => void; + reFetchObservableQueries(includeStandby?: boolean): Promise[]>; + refetchQueries, TResult>( + options: RefetchQueriesOptions + ): RefetchQueriesResult; + getObservableQueries(include?: RefetchQueriesInclude): Map>; + extract(optimistic?: boolean): TCacheShape; + restore(serializedState: TCacheShape): ApolloCache; + addResolvers(resolvers: Resolvers | Resolvers[]): void; + setResolvers(resolvers: Resolvers | Resolvers[]): void; + getResolvers(): Resolvers; + setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void; + setLink(newLink: ApolloClient$ApolloLink): void; + } + + // @apollo/client/react/components/Mutation.d.ts + + declare export function Mutation( + props: MutationComponentOptions + ): Node; + + // @apollo/client/react/components/Query.d.ts + + declare export function Query( + props: QueryComponentOptions + ): Node; + + // @apollo/client/react/components/Subscription.d.ts + + declare export function Subscription( + props: SubscriptionComponentOptions + ): Node; + + // @apollo/client/react/components/types.d.ts + + declare export type QueryComponentOptions = { + children: (result: QueryResult) => React$Node | null, + query: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & QueryFunctionOptions; + declare export type MutationComponentOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = { + mutation: GraphQL$DocumentNode | TypedDocumentNode, + children: ( + mutateFunction: MutationFunction, + result: MutationResult + ) => React$Node | null, + ... + } & BaseMutationOptions; + declare export type SubscriptionComponentOptions = { + subscription: GraphQL$DocumentNode | TypedDocumentNode, + children?: null | ((result: SubscriptionResult) => React$Node | null), + ... + } & BaseSubscriptionOptions; + + // @apollo/client/react/context/ApolloConsumer.d.ts + + declare export interface ApolloConsumerProps { + children: (client: ApolloClient<{ [key: string]: any }>) => Node | null; + } + declare export var ApolloConsumer: ComponentType; + + // @apollo/client/react/context/ApolloContext.d.ts + + declare export interface ApolloContextValue { + client?: ApolloClient<{ [key: string]: any }>; + renderPromises?: RenderPromises; + } + declare export function getApolloContext(): Context; + + // @apollo/client/react/context/ApolloProvider.d.ts + + declare export interface ApolloProviderProps { + client: ApolloClient; + children: Node | Node[] | null; + } + declare export var ApolloProvider: ComponentType>; + + // @apollo/client/react/hoc/graphql.d.ts + + declare export function graphql( + document: GraphQL$DocumentNode, + operationOptions?: OperationOption + ): (WrappedComponent: React$ComponentType<{| ...TProps, ...TChildProps |}>) => React$Component; + + // @apollo/client/react/hoc/hoc-utils.d.ts + + declare export var defaultMapPropsToOptions: () => { ... }; + declare export var defaultMapResultToProps:

(props: P) => P; + declare export var defaultMapPropsToSkip: () => boolean; + declare export function getDisplayName

(WrappedComponent: ComponentType

): string; + declare export function calculateVariablesFromProps( + operation: IDocumentDefinition, + props: TProps + ): OperationVariables; + declare export type RefSetter = (ref: Component) => void | void; + declare export class GraphQLBase extends React$Component { + withRef: boolean; + constructor(props: TProps): this; + getWrappedInstance(): Component | void; + setWrappedInstance(ref: Component): void; + } + + // @apollo/client/react/hoc/mutation-hoc.d.ts + + declare export function withMutation< + TProps: { ... }, + TData: { [key: string]: any, ... }, + TGraphQLVariables, + TChildProps, + TContext, + TCache: ApolloCache + >( + document: GraphQL$DocumentNode, + operationOptions?: OperationOption + ): (WrappedComponent: ComponentType<{| ...TProps, ...TChildProps |}>) => Component; + + // @apollo/client/react/hoc/query-hoc.d.ts + + declare export function withQuery( + document: GraphQL$DocumentNode, + operationOptions?: OperationOption + ): (WrappedComponent: ComponentType<{| ...TProps, ...TChildProps |}>) => Component; + + // @apollo/client/react/hoc/subscription-hoc.d.ts + + declare function withSubscription( + document: GraphQL$DocumentNode, + operationOptions?: OperationOption + ): (WrappedComponent: ComponentType<{| ...TProps, ...TChildProps |}>) => Component; + + // @apollo/client/react/hoc/types.d.ts + + declare export interface QueryControls { + error?: ApolloError; + networkStatus: number; + loading: boolean; + variables: TGraphQLVariables; + fetchMore: (fetchMoreOptions: {| + ...FetchMoreQueryOptions, + ...FetchMoreOptions, + |}) => Promise>; + refetch: (variables?: TGraphQLVariables) => Promise>; + startPolling: (pollInterval: number) => void; + stopPolling: () => void; + subscribeToMore: (options: SubscribeToMoreOptions<>) => () => void; + updateQuery: (mapFn: (previousQueryResult: any, options: UpdateQueryOptions) => any) => void; + } + declare export type DataValue = {| + ...QueryControls, + ...$Rest, + |}; + declare export interface DataProps { + data: DataValue; + } + declare export interface MutateProps { + mutate: MutationFunction; + result: MutationResult; + } + declare export type ChildProps = {| + ...TProps, + ...$Rest, { ... }>, + ...$Rest, { ... }>, + |}; + declare export type ChildDataProps = {| + ...TProps, + ...DataProps, + |}; + declare export type ChildMutateProps = {| + ...TProps, + ...MutateProps, + |}; + declare export type OptionProps = { + ownProps: TProps, + ... + } & $Rest, { ... }> & + $Rest, { ... }>; + declare export interface OperationOption< + TProps, + TData, + TGraphQLVariables = OperationVariables, + TChildProps = ChildProps, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > { + options?: + | BaseQueryOptions + | BaseMutationOptions + | (( + props: TProps + ) => BaseQueryOptions | BaseMutationOptions); + props?: (props: OptionProps, lastProps?: TChildProps | void) => TChildProps; + skip?: boolean | ((props: TProps) => boolean); + name?: string; + withRef?: boolean; + shouldResubscribe?: (props: TProps, nextProps: TProps) => boolean; + alias?: string; + } + declare export type WithApolloClient

= { + ...P, + client?: ApolloClient, + ... + }; + + // @apollo/client/react/hoc/withApollo.d.ts + + declare export function withApollo( + WrappedComponent: ComponentType>>, + operationOptions?: OperationOption + ): Component<$Diff>; + + // @apollo/client/react/hooks/useApolloClient.d.ts + + declare export function useApolloClient( + override?: ApolloClient<{ [key: string]: any }> + ): ApolloClient<{ [key: string]: any }>; + + // @apollo/client/react/hooks/useFragment.d.ts + + declare export type UseFragmentOptions = { + from: StoreObject | Reference | string, + optimistic?: boolean, + ... + } & $Diff, {| id: any, query: any, optimistic: any, previousResult: any |}> & + $Diff, {| id: any |}>; + declare export interface UseFragmentResult { + data: TData | void; + complete: boolean; + missing?: MissingTree; + } + declare export function useFragment_experimental( + options: UseFragmentOptions + ): UseFragmentResult; + + // @apollo/client/react/hooks/useLazyQuery.d.ts + + declare export function useLazyQuery( + query: GraphQL$DocumentNode | TypedDocumentNode, + options?: LazyQueryHookOptions + ): LazyQueryResultTuple; + + // @apollo/client/react/hooks/useMutation.d.ts + + declare export function useMutation< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + >( + mutation: GraphQL$DocumentNode | TypedDocumentNode, + options?: MutationHookOptions + ): MutationTuple; + + // @apollo/client/react/hooks/useQuery.d.ts + + declare export function useQuery( + query: GraphQL$DocumentNode | TypedDocumentNode, + options?: QueryHookOptions + ): QueryResult; + declare export function useInternalState( + client: ApolloClient, + query: GraphQL$DocumentNode | TypedDocumentNode + ): InternalState; + declare export class InternalState { + +client: $Call<((...args: any[]) => R) => R, typeof useApolloClient>; + +query: GraphQL$DocumentNode | TypedDocumentNode; + constructor( + client: $Call<((...args: any[]) => R) => R, typeof useApolloClient>, + query: GraphQL$DocumentNode | TypedDocumentNode, + previous?: InternalState + ): this; + forceUpdate(): void; + asyncUpdate(): Promise>; + useQuery(options: QueryHookOptions): QueryResult; + getDefaultFetchPolicy(): WatchQueryFetchPolicy; + toQueryResult(result: ApolloQueryResult): QueryResult; + } + + // @apollo/client/react/hooks/useReactiveVar.d.ts + + declare export function useReactiveVar(rv: ReactiveVar): T; + + // @apollo/client/react/hooks/useSubscription.d.ts + + declare export function useSubscription( + subscription: GraphQL$DocumentNode | TypedDocumentNode, + options?: SubscriptionHookOptions + ): SubscriptionResult; + + // @apollo/client/react/parser/index.d.ts + + declare export var DocumentType: {| + +Query: 0, + +Mutation: 1, + +Subscription: 2, + |}; + declare export interface IDocumentDefinition { + type: $Values; + name: string; + variables: $ReadOnlyArray; + } + declare export function operationName(type: $Values): string; + declare export function parser(document: GraphQL$DocumentNode): IDocumentDefinition; + declare export function verifyDocumentType(document: GraphQL$DocumentNode, type: $Values): void; + + // @apollo/client/react/ssr/getDataFromTree.d.ts + + declare export function getDataFromTree( + tree: Node, + context?: { + [key: string]: any, + } + ): Promise; + declare export type GetMarkupFromTreeOptions = { + tree: Node, + context?: { + [key: string]: any, + }, + renderFunction?: (tree: Element) => string | Promise, + ... + }; + declare export function getMarkupFromTree(x: GetMarkupFromTreeOptions): Promise; + + // @apollo/client/react/ssr/RenderPromises.d.ts + + declare export interface QueryData { + getOptions(): any; + fetchData(): Promise; + } + declare export class RenderPromises { + stop(): void; + registerSSRObservable(observable: ObservableQuery): void; + getSSRObservable( + props: QueryDataOptions + ): ObservableQuery | null; + addQueryPromise(queryInstance: QueryData, finish?: () => Node): Node; + addObservableQueryPromise( + obsQuery: ObservableQuery + ): Node; + hasPromises(): boolean; + consumeAndAwaitPromises(): Promise; + } + + // @apollo/client/react/ssr/RenderPromises.d.ts + + declare export function renderToStringWithData(component: Element): Promise; + + // @apollo/client/react/types/types.d.ts + + declare export type CommonOptions = { + ...TOptions, + client?: ApolloClient<{ [key: string]: any }>, + ... + }; + declare export type BaseQueryOptions = { + ssr?: boolean, + client?: ApolloClient, + context?: DefaultContext, + ... + } & $Diff, {| query: any |}>; + declare export type QueryFunctionOptions = { + skip?: boolean, + onCompleted?: (data: TData) => void, + onError?: (error: ApolloError) => void, + defaultOptions?: $Rest, { ... }>, + ... + } & BaseQueryOptions; + declare export type ObservableQueryFields = {| + startPolling(pollInterval: number): void; + stopPolling(): void; + subscribeToMore( + options: SubscribeToMoreOptions + ): () => void; + updateQuery( + mapFn: (previousQueryResult: TData, options: OperationVariables) => TData + ): void; + refetch(variables?: $Rest): Promise>; + reobserve( + newOptions?: $Rest, { ... }>, + newNetworkStatus?: $Values + ): Promise>; + variables: TVariables | void; + fetchMore(fetchMoreOptions: { + ...FetchMoreQueryOptions, + updateQuery?: ( + previousQueryResult: TData, + options: { + fetchMoreResult: TFetchData, + variables: TFetchVars, + ... + } + ) => TData, + ... + }): Promise>; + |}; + declare export type QueryResult = { + client: ApolloClient, + observable: ObservableQuery, + data: TData | void, + previousData?: TData, + error?: ApolloError, + loading: boolean, + networkStatus: typeof NetworkStatus, + called: boolean, + ... + } & ObservableQueryFields; + declare export type QueryDataOptions = { + children?: (result: QueryResult) => Node, + query: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & QueryFunctionOptions; + declare export type QueryHookOptions = { + query?: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & QueryFunctionOptions; + declare export type LazyQueryHookOptions = { ... } & $Diff< + QueryHookOptions, + {| skip: any |} + >; + declare export interface QueryLazyOptions { + variables?: TVariables; + context?: DefaultContext; + } + declare export type LazyQueryResult = QueryResult; + declare export type QueryTuple = LazyQueryResultTuple; + declare export type LazyQueryExecFunction = ( + options?: $Rest, { ... }> + ) => Promise>; + declare export type LazyQueryResultTuple = [ + LazyQueryExecFunction, + QueryResult + ]; + declare export type RefetchQueriesFunction = (...args: any[]) => InternalRefetchQueriesInclude; + declare export type BaseMutationOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = { + client?: ApolloClient<{ [key: string]: any }>, + notifyOnNetworkStatusChange?: boolean, + onCompleted?: (data: TData, clientOptions?: BaseMutationOptions<>) => void, + onError?: (error: ApolloError, clientOptions?: BaseMutationOptions<>) => void, + ignoreResults?: boolean, + ... + } & $Diff, {| mutation: any |}>; + declare export type MutationFunctionOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = { + mutation?: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & BaseMutationOptions; + declare export interface MutationResult { + data?: TData | null; + error?: ApolloError; + loading: boolean; + called: boolean; + client: ApolloClient<{ [key: string]: any }>; + reset(): void; + } + declare export type MutationFunction< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = (options?: MutationFunctionOptions) => Promise>; + declare export type MutationHookOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = { + mutation?: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & BaseMutationOptions; + declare export type MutationDataOptions< + TData = any, + TVariables = OperationVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = { + mutation: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & BaseMutationOptions; + declare export type MutationTuple< + TData, + TVariables, + TContext = DefaultContext, + TCache: ApolloCache = ApolloCache + > = [ + (options?: MutationFunctionOptions) => Promise>, + MutationResult + ]; + declare export interface OnDataOptions { + client: ApolloClient<{ [key: string]: any }>; + data: SubscriptionResult; + } + declare export interface OnSubscriptionDataOptions { + client: ApolloClient<{ [key: string]: any }>; + subscriptionData: SubscriptionResult; + } + declare export interface BaseSubscriptionOptions { + variables?: TVariables; + fetchPolicy?: FetchPolicy; + shouldResubscribe?: boolean | ((options: BaseSubscriptionOptions) => boolean); + client?: ApolloClient<{ [key: string]: any }>; + skip?: boolean; + context?: DefaultContext; + onComplete?: () => void; + onData?: (options: OnDataOptions) => any; + onSubscriptionData?: (options: OnSubscriptionDataOptions) => any; + onError?: (error: ApolloError) => void; + onSubscriptionComplete?: () => void; + } + declare export interface SubscriptionResult { + loading: boolean; + data?: TData; + error?: ApolloError; + variables?: TVariables; + } + declare export type SubscriptionHookOptions = { + subscription?: GraphQL$DocumentNode | TypedDocumentNode, + ... + } & BaseSubscriptionOptions; + declare export type SubscriptionDataOptions = { + subscription: GraphQL$DocumentNode | TypedDocumentNode, + children?: null | ((result: SubscriptionResult) => React$Node | null), + ... + } & BaseSubscriptionOptions; + declare export interface SubscriptionCurrentObservable { + query?: ZenObservable$Observable; + subscription?: ZenObservable$ObservableSubscription; + } + + // @apollo/client/link/http/iterators/async.d.ts + + declare export function asyncIterator(source: AsyncIterator): AsyncIterator; + + // @apollo/client/link/http/iterators/promise.d.ts + + declare export function promiseIterator(promise: Promise): AsyncIterator; + + // @apollo/client/link/http/checkFetcher.d.ts + + declare export var checkFetcher: (fetcher: typeof fetch | void) => void; + + // @apollo/client/link/http/createHttpLink.d.ts + + declare export var createHttpLink: (linkOptions?: HttpOptions) => ApolloClient$ApolloLink; + + // @apollo/client/link/http/createSignalIfSupported.d.ts + + declare export var createSignalIfSupported: () => + | { + controller: boolean, + signal: boolean, + ... + } + | { + controller: AbortController, + signal: AbortSignal, + ... + }; + + // @apollo/client/link/http/HttpLink.d.ts + + declare export class HttpLink mixins ApolloClient$ApolloLink { + options: HttpOptions; + requester: ApolloClient$RequestHandler; + constructor(options?: HttpOptions): this; + } + + // @apollo/client/link/http/parseAndCheckHttpResponse.d.ts + + declare export type ServerParseError = {| + ...Error, + response: Response, + statusCode: number, + bodyText: string, + |}; + declare export function readMultipartBody(response: Response, observer: ZenObservable$Observer): Promise; + declare export function parseHeaders( + headerText: string + ): { + [key: string]: string, + ..., + }; + declare export function parseJsonBody(response: Response, bodyText: string): T; + declare export function handleError(err: any, observer: ZenObservable$Observer): void; + declare export function readJsonBody(response: Response, operation: ApolloClient$Operation, observer: ZenObservable$Observer): void; + declare export function parseAndCheckHttpResponse( + operations: ApolloClient$Operation | ApolloClient$Operation[] + ): (response: Response) => Promise; + + // @apollo/client/link/http/rewriteURIForGET.d.ts + + declare export function rewriteURIForGET( + chosenURI: string, + body: Body + ): + | { + parseError: any, + newURI?: void, + ... + } + | { + newURI: string, + parseError?: void, + ... + }; + + // @apollo/client/link/http/selectHttpOptionsAndBody.d.ts + + declare export interface Printer { + (node: ASTNode, originalPrint: typeof print): string; + } + declare export interface UriFunction { + (operation: ApolloClient$Operation): string; + } + declare export interface Body { + query?: string; + operationName?: string; + variables?: { [key: string]: any, ... }; + extensions?: { [key: string]: any, ... }; + } + declare export type HttpOptions = {| + uri?: string | UriFunction, + includeExtensions?: boolean, + fetch?: typeof fetch, + headers?: any, + preserveHeaderCase?: boolean, + credentials?: string, + fetchOptions?: any, + useGETForQueries?: boolean, + includeUnusedVariables?: boolean, + print?: Printer, + |}; + declare export interface HttpQueryOptions { + includeQuery?: boolean; + includeExtensions?: boolean; + preserveHeaderCase?: boolean; + } + declare export interface HttpConfig { + http?: HttpQueryOptions; + options?: any; + headers?: any; + credentials?: any; + } + declare export var fallbackHttpConfig: { + http: HttpQueryOptions, + headers: { + accept: string, + "content-type": string, + ... + }, + options: { + method: string, + ... + }, + ... + }; + declare export var defaultPrinter: Printer; + declare export function selectHttpOptionsAndBody( + operation: ApolloClient$Operation, + fallbackConfig: HttpConfig, + ...configs: Array + ): { + options: { ...HttpConfig, [key: string]: any, ... }, + body: Body, + ... + }; + declare export function selectHttpOptionsAndBodyInternal( + operation: ApolloClient$Operation, + printer: Printer, + ...configs: HttpConfig[] + ): { + options: { ...HttpConfig, [key: string]: any, ... }, + body: Body, + ... + }; + + // @apollo/client/link/http/selectURI.d.ts + + declare export var selectURI: ( + operation: ApolloClient$Operation, + fallbackURI?: string | ((operation: ApolloClient$Operation) => string) | void + ) => any; + + // @apollo/client/link/http/serializeFetchParameter.d.ts + + declare export type ClientParseError = { + ...InvariantError, + parseError: Error, + ... + }; + declare export var serializeFetchParameter: (p: any, label: string) => string; + + // @apollo/client/link/utils/createOperation.d.ts + + declare function createOperation(starting: any, operation: ApolloClient$GraphQLRequest): ApolloClient$Operation; + + // @apollo/client/link/utils/fromError.d.ts + + declare function fromError(errorValue: any): ZenObservable$Observable; + + // @apollo/client/link/utils/fromPromise.d.ts + + declare function fromPromise(promise: Promise): ZenObservable$Observable; + + // @apollo/client/link/utils/throwServerError.d.ts + + declare type ServerError = { + ...Error, + response: Response, + result: { [key: string]: any, ... }, + statusCode: number, + ... + }; + declare var throwServerError: (response: Response, result: any, message: string) => empty; + + // @apollo/client/link/utils/toPromise.d.ts + + declare function toPromise(observable: ZenObservable$Observable): Promise; + + // @apollo/client/link/utils/transformOperation.d.ts + + declare function transformOperation(operation: ApolloClient$GraphQLRequest): ApolloClient$GraphQLRequest; + + // @apollo/client/link/utils/validateOperation.d.ts + + declare function validateOperation(operation: ApolloClient$GraphQLRequest): ApolloClient$GraphQLRequest; +} + +declare module "@apollo/client/link/batch" { + // @apollo/client/link/batch/batching.d.ts + + declare export type BatchHandler = ( + operations: ApolloClient$Operation[], + forward?: (ApolloClient$NextLink | void)[] + ) => ZenObservable$Observable[]> | null; + declare export interface BatchableRequest { + operation: ApolloClient$Operation; + forward?: ApolloClient$NextLink; + } + declare export class OperationBatcher { + constructor(x: { + batchDebounce?: boolean, + batchInterval?: number, + batchMax?: number, + batchHandler: BatchHandler, + batchKey?: (operation: ApolloClient$Operation) => string, + ... + }): this; + enqueueRequest(request: BatchableRequest): ZenObservable$Observable>; + consumeQueue(key?: string): (ZenObservable$Observable> | void)[] | void; + } + + // @apollo/client/link/batch/batchLink.d.ts + + declare export interface BatchLink$Options { + batchInterval?: number; + batchDebounce?: boolean; + batchMax?: number; + batchHandler?: BatchHandler; + batchKey?: (operation: ApolloClient$Operation) => string; + } + declare export class BatchLink extends ApolloClient$ApolloLink { + constructor(fetchParams?: BatchLink$Options): this; + request(operation: ApolloClient$Operation, forward?: ApolloClient$NextLink): ZenObservable$Observable> | null; + } +} + +declare module "@apollo/client/link/batch-http" { + import type { HttpOptions } from "@apollo/client"; + + // @apollo/client/link/batch-http/batchHttpLink.d.ts + + declare export type BatchHttpLink$Options = {| + batchInterval?: number, + batchDebounce?: boolean, + batchMax?: number, + batchKey?: (operation: ApolloClient$Operation) => string, + ...HttpOptions, + |}; + declare export class BatchHttpLink extends ApolloClient$ApolloLink { + constructor(fetchParams?: BatchHttpLink$Options): this; + request(operation: ApolloClient$Operation): ZenObservable$Observable> | null; + } +} + +declare module "@apollo/client/link/context" { + // @apollo/client/link/context/index.d.ts + + declare export type ContextSetter = (operation: ApolloClient$GraphQLRequest, prevContext: any) => Promise | any; + declare export function setContext(setter: ContextSetter): ApolloClient$ApolloLink; +} + +declare module "@apollo/client/link/core" { + // @apollo/client/link/core/ApolloLink.d.ts + + declare export class ApolloLink extends ApolloClient$ApolloLink {} + + // @apollo/client/link/core/types.d.ts + + declare export type Path = ApolloClient$Path; + declare export type Data = ApolloClient$Data; + declare export interface ExecutionPatchResultBase extends ApolloClient$ExecutionPatchResultBase {} + declare export type ExecutionPatchInitialResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$ExecutionPatchInitialResult; + declare export interface IncrementalPayload extends ApolloClient$IncrementalPayload {} + declare export type ExecutionPatchIncrementalResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$ExecutionPatchIncrementalResult; + declare export type ExecutionPatchResult< + TData = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$ExecutionPatchResult; + declare export interface GraphQLRequest extends ApolloClient$GraphQLRequest {} + declare export interface Operation extends ApolloClient$Operation {} + declare export type SingleExecutionResult< + TData = { [key: string]: any, ... }, + TContext = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$SingleExecutionResult; + declare export type FetchResult< + TData = { [key: string]: any, ... }, + TContext = { [key: string]: any, ... }, + TExtensions = { [key: string]: any, ... } + > = ApolloClient$FetchResult + declare export type NextLink = ApolloClient$NextLink; + declare export type RequestHandler = ApolloClient$RequestHandler; +} + +declare module "@apollo/client/link/error" { + import type { GraphQLErrors, NetworkError } from "@apollo/client"; + + // @apollo/client/link/error/index.d.ts + + declare export interface ErrorResponse { + graphQLErrors?: GraphQLErrors; + networkError?: NetworkError; + response?: GraphQL$ExecutionResult<>; + operation: ApolloClient$Operation; + forward: ApolloClient$NextLink; + } + + declare export var npm$namespace$ErrorLink: {| + ErrorHandler: Class, + |}; + declare export interface ErrorLink$ErrorHandler { + (error: ErrorResponse): ZenObservable$Observable> | void; + } + declare export var ErrorHandler: ErrorLink$ErrorHandler; + declare export function onError(errorHandler: ErrorLink$ErrorHandler): ApolloClient$ApolloLink; + declare export class ErrorLink extends ApolloClient$ApolloLink { + constructor(errorHandler: ErrorLink$ErrorHandler): this; + request(operation: ApolloClient$Operation, forward?: ApolloClient$NextLink): ZenObservable$Observable> | null; + } +} + +declare module "@apollo/client/link/persisted-queries" { + import type { NetworkError } from "@apollo/client"; + + // @apollo/client/link/persisted-queries/index.d.ts + + declare export var VERSION: 1; + declare export interface ErrorResponse { + graphQLErrors?: $ReadOnlyArray; + networkError?: NetworkError; + response?: GraphQL$ExecutionResult<>; + operation: ApolloClient$Operation; + } + declare type SHA256Function = (...args: any[]) => string | Promise; + declare type GenerateHashFunction = (document: GraphQL$DocumentNode) => string | Promise; + declare var PersistedQueryLink: typeof npm$namespace$PersistedQueryLink; + + declare var npm$namespace$PersistedQueryLink: {| + BaseOptions: Class, + SHA256Options: Class, + GenerateHashOptions: Class, + |}; + declare interface PersistedQueryLink$BaseOptions { + disable?: (error: ErrorResponse) => boolean; + useGETForHashedQueries?: boolean; + } + + declare type PersistedQueryLink$SHA256Options = { + sha256: SHA256Function, + generateHash?: empty, + ... + } & PersistedQueryLink$BaseOptions; + + declare type PersistedQueryLink$GenerateHashOptions = { + sha256?: empty, + generateHash: GenerateHashFunction, + ... + } & PersistedQueryLink$BaseOptions; + + declare export type PersistedQueryLink$Options = + | PersistedQueryLink$SHA256Options + | PersistedQueryLink$GenerateHashOptions; + + declare export var createPersistedQueryLink: (options: PersistedQueryLink$Options) => ApolloClient$ApolloLink; +} + +declare module "@apollo/client/link/retry" { + // @apollo/client/link/retry/delayFunction.d.ts + + declare export interface DelayFunction { + (count: number, operation: ApolloClient$Operation, error: any): number; + } + declare export interface DelayFunctionOptions { + initial?: number; + max?: number; + jitter?: boolean; + } + declare export function buildDelayFunction(delayOptions?: DelayFunctionOptions): DelayFunction; + + // @apollo/client/link/retry/retryFunction.d.ts + + declare export interface RetryFunction { + (count: number, operation: ApolloClient$Operation, error: any): boolean | Promise; + } + declare export interface RetryFunctionOptions { + max?: number; + retryIf?: (error: any, operation: ApolloClient$Operation) => boolean | Promise; + } + declare export function buildRetryFunction(retryOptions?: RetryFunctionOptions): RetryFunction; + + // @apollo/client/link/retry/retryLink.d.ts + + declare export interface RetryLink$Options { + delay?: DelayFunctionOptions | DelayFunction; + attempts?: RetryFunctionOptions | RetryFunction; + } + declare export class RetryLink extends ApolloClient$ApolloLink { + constructor(options?: RetryLink$Options): this; + request(operation: ApolloClient$Operation, nextLink?: ApolloClient$NextLink): ZenObservable$Observable>; + } +} + +declare module "@apollo/client/link/schema" { + import type { GraphQLSchema } from "@apollo/client"; + + // @apollo/client/link/schema/index.d.ts + + declare export var SchemaLink: typeof npm$namespace$SchemaLink; + + declare var npm$namespace$SchemaLink: {| + SchemaLink: typeof SchemaLink$SchemaLink, + |}; + declare export class SchemaLink$SchemaLink { + constructor(options: SchemaLink$Options): this; + request(operation: ApolloClient$Operation): ZenObservable$Observable>; + } + declare export type SchemaLink$ResolverContext = { ... }; + declare export type SchemaLink$ResolverContextFunction = (operation: ApolloClient$Operation) => SchemaLink$ResolverContext | Promise; + declare export interface SchemaLink$Options { + schema: GraphQLSchema; + rootValue?: any; + context?: SchemaLink$ResolverContext | SchemaLink$ResolverContextFunction; + validate?: boolean; + } +} + +declare module "@apollo/client/link/subscriptions" { + import type { GraphQLSchema } from "@apollo/client"; + + // @apollo/client/link/subscriptions/index.d.ts + + declare var npm$namespace$SchemaLink: {| + Options: Class, + |}; + declare type SchemaLink$ResolverContext = { [key: string]: any, ... }; + + declare type SchemaLink$ResolverContextFunction = ( + operation: ApolloClient$Operation + ) => SchemaLink$ResolverContext | Promise; + + declare interface SchemaLink$Options { + schema: GraphQLSchema; + rootValue?: any; + context?: SchemaLink$ResolverContext | SchemaLink$ResolverContextFunction; + validate?: boolean; + } + declare export class SchemaLink extends ApolloClient$ApolloLink { + schema: $PropertyType; + rootValue: $PropertyType; + context: $PropertyType; + validate: boolean; + constructor(options: SchemaLink$Options): this; + request(operation: ApolloClient$Operation): ZenObservable$Observable>; + } +} + +declare module "@apollo/client/link/ws" { + // @apollo/client/link/ws/index.d.ts + + declare var npm$namespace$WebSocketLink: {| + Configuration: Class, + |}; + declare interface WebSocketLink$Configuration { + uri: string; + options?: any; + webSocketImpl?: any; + } + declare export var WebSocketParams: WebSocketLink$Configuration; + declare export class WebSocketLink extends ApolloClient$ApolloLink { + constructor(paramsOrClient: WebSocketLink$Configuration): this; + request(operation: ApolloClient$Operation): ZenObservable$Observable> | null; + } +} + +declare module "@apollo/client/testing" { + import type { ApolloCache, ApolloClient, ApolloQueryResult, DefaultOptions, NormalizedCacheObject, ObservableQuery, QueryManager, Resolvers } from "@apollo/client"; + + // Typescript built-in type + declare type RequestInit = any; + + // @apollo/client/testing/core/mocking/mockClient.d.ts + + declare function createMockClient( + data: TData, + query: GraphQL$DocumentNode, + variables?: { ... } + ): ApolloClient; + + // @apollo/client/testing/core/mocking/mockFetch.d.ts + + declare interface MockedIResponse { + ok: boolean; + status: number; + statusText?: string; + json(): Promise; + } + declare interface MockedFetchResponse { + url: string; + opts: RequestInit; + result: MockedIResponse; + delay?: number; + } + declare function createMockedIResponse(result: Object, options?: any): MockedIResponse; + declare class MockFetch { + constructor(...mockedResponses: MockedFetchResponse[]): this; + addMockedResponse(mockedResponse: MockedFetchResponse): void; + fetch(url: string, opts: RequestInit): Promise; + fetchParamsToKey(url: string, opts: RequestInit): string; + getFetch(): any; + } + declare function createMockFetch(...mockedResponses: MockedFetchResponse[]): any; + + // @apollo/client/testing/core/mocking/mockLink.d.ts + + declare type ResultFunction = () => T; + declare type MockedResponse = {| + request: ApolloClient$GraphQLRequest; + result?: ApolloClient$FetchResult | ResultFunction>; + error?: Error; + delay?: number; + newData?: ResultFunction>; + |}; + declare class MockLink extends ApolloClient$ApolloLink { + operation: ApolloClient$Operation; + addTypename: Boolean; + constructor(mockedResponses: $ReadOnlyArray>, addTypename?: Boolean): this; + addMockedResponse(mockedResponse: MockedResponse<>): void; + request(operation: ApolloClient$Operation): ZenObservable$Observable> | null; + } + declare type MockApolloLink = { + operation?: ApolloClient$Operation, + ... + } & ApolloClient$ApolloLink; + declare function mockSingleLink(...mockedResponses: Array): MockApolloLink; + + // @apollo/client/testing/core/mocking/mockQueryManager.d.ts + + declare var _default: ( + reject: (reason: any) => any, + ...mockedResponses: MockedResponse<>[] + ) => QueryManager; + declare export default typeof _default; + + // @apollo/client/testing/core/mocking/mockSubscriptionLink.d.ts + + declare interface MockedSubscription { + request: ApolloClient$Operation; + } + declare interface MockedSubscriptionResult { + result?: ApolloClient$FetchResult<>; + error?: Error; + delay?: number; + } + declare class MockSubscriptionLink extends ApolloClient$ApolloLink { + unsubscribers: any[]; + setups: any[]; + operation: ApolloClient$Operation; + constructor(): this; + request( + operation: ApolloClient$Operation + ): ZenObservable$Observable>; + simulateResult(result: MockedSubscriptionResult, complete?: boolean): void; + simulateComplete(): void; + onSetup(listener: any): void; + onUnsubscribe(listener: any): void; + } + declare function mockObservableLink(): MockSubscriptionLink; + + // @apollo/client/testing/core/observableToPromise.d.ts + + declare type Options = { + observable: ObservableQuery, + shouldResolve?: boolean, + wait?: number, + errorCallbacks?: ((error: Error) => any)[], + ... + }; + declare type ResultCallback = (result: ApolloQueryResult) => any; + declare function observableToPromiseAndSubscription( + x: Options, + ...cbs: ResultCallback[] + ): { + promise: Promise, + subscription: ZenObservable$ObservableSubscription, + ... + }; + + // @apollo/client/testing/core/subscribeAndCount.d.ts + + declare function subscribeAndCount( + reject: (reason: any) => any, + observable: ZenObservable$Observable, + cb: (handleCount: number, result: TResult) => any + ): ZenObservable$ObservableSubscription; + + // @apollo/client/testing/core/withConsoleSpy.d.ts + + declare function withErrorSpy(it: (...args: TArgs) => TResult, ...args: TArgs): TResult; + declare function withWarningSpy(it: (...args: TArgs) => TResult, ...args: TArgs): TResult; + declare function withLogSpy(it: (...args: TArgs) => TResult, ...args: TArgs): TResult; + + // @apollo/client/testing/core/wrap.d.ts + + declare function withError(func: Function, regex: RegExp): any; + + // @apollo/client/testing/react/MockedProvider.d.ts + + declare type MockedProviderProps = {| + mocks?: $ReadOnlyArray>; + addTypename?: boolean; + defaultOptions?: DefaultOptions; + cache?: ApolloCache; + resolvers?: Resolvers; + childProps?: { [key: string]: any }; + children?: any; + link?: ApolloClient$ApolloLink; + |}; + declare interface MockedProviderState { + client: ApolloClient; + } + declare export class MockedProvider mixins React$Component, MockedProviderState> { + static defaultProps: MockedProviderProps<>; + constructor(props: MockedProviderProps<>): this; + render(): React$Node | null; + componentWillUnmount(): void; + } +} diff --git a/definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/test_client_v3.x.x.js b/definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/test_client_v3.x.x.js new file mode 100644 index 0000000000..589fb45d0b --- /dev/null +++ b/definitions/npm/@apollo/client_v3.x.x/flow_v0.142.x-/test_client_v3.x.x.js @@ -0,0 +1,130 @@ +// @flow + +import { describe, it } from 'flow-typed-test'; +import { ApolloCache, ApolloClient, ApolloLink, ApolloProvider, useSubscription } from '@apollo/client'; +import type { FetchResult, OnSubscriptionDataOptions } from '@apollo/client'; +import { MockedProvider } from "@apollo/client/testing"; +import * as React from 'react'; +import { RetryLink } from '@apollo/client/link/retry'; + +const client = new ApolloClient({ cache: new ApolloCache() }); + +type MutationData = {| + id: string, +|}; + +type MutationVariables = {| + myVar: string, +|}; + +describe('ApolloLink', () => { + it('concatenates from an array of links', () => { + const link = ApolloLink.from([new RetryLink()]); + }); + + it('rejects construction from wrong type', () => { + class BadLink {} + + // $FlowExpectedError[incompatible-call] + const link = ApolloLink.from([new BadLink()]); + }); +}); + +describe('ApolloClient', () => { + describe('mutate', () => { + it('returns data type', async () => { + const result: FetchResult = await client.mutate({ mutation: {}, variables: { myVar: 'foo' } }); + const data: ?MutationData = result.data; + + // $FlowExpectedError[prop-missing] + const notData: ?{| wrong: string |} = result.data; + }); + it('accepts correct variables type', () => { + client.mutate({ mutation: {}, variables: { myVar: 'foo' } }); + }); + it('rejects wrong variables type', () => { + // $FlowExpectedError[prop-missing] + client.mutate({mutation: {}, variables: {wrongVariable: 99}}); + }); + }); +}); + +type SubscriptionData = {| + id: string, +|}; + +type SubscriptionVariables = {| + scope: string, +|}; + +type WrongData = {| + wrong: "type", +|}; + +describe('useSubscription', () => { + it('obSubscriptionData accepts correct subscription data type', () => { + const query = {}; + const onSubscriptionData = (data: OnSubscriptionDataOptions) => { + const subscriptionData: ?SubscriptionData = data.subscriptionData.data; + }; + useSubscription(query, { onSubscriptionData }); + }); + + it('obSubscriptionData rejects wrong subscription data type', () => { + const query = {}; + const onSubscriptionData = (data: OnSubscriptionDataOptions) => { + const subscriptionData: ?WrongData = data.subscriptionData.data; + }; + // $FlowExpectedError[prop-missing] + useSubscription(query, { onSubscriptionData }); + }); +}); + +describe('ApolloProvider', () => { + it('accepts a client and children', () => { +
; + }); + + it('requires a client', () => { + // $FlowExpectedError[prop-missing] +
; + }); + + it('requires children', () => { + // $FlowExpectedError[prop-missing] + ; + }); +}); + +describe('MockedProvider', () => { + it('accepts mocks', () => { + const query = {}; + const mocks = [ + { + request: { + query, + variables: { + filters: { + startDate: null, + endDate: null, + contractingCompanyIds: null, + maintenanceEventIds: null, + subsystemIds: null, + }, + contractingCompanyIds: null, + maintenanceEventIds: null, + subsystemIds: null, + }, + }, + result: { + data: { + getChartData: { + chartData: [], + } + }, + }, + }, + ]; +
; + }); +}); From e420967f1d88dc042409e9e70ac034ffb968a222 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 5 Jan 2023 11:25:20 -0500 Subject: [PATCH 4/7] Bump json5 from 2.1.1 to 2.2.3 in /cli (#4416) Bumps [json5](https://github.com/json5/json5) from 2.1.1 to 2.2.3. - [Release notes](https://github.com/json5/json5/releases) - [Changelog](https://github.com/json5/json5/blob/main/CHANGELOG.md) - [Commits](https://github.com/json5/json5/compare/v2.1.1...v2.2.3) --- updated-dependencies: - dependency-name: json5 dependency-type: indirect ... Signed-off-by: dependabot[bot] Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- cli/yarn.lock | 22 ++++------------------ 1 file changed, 4 insertions(+), 18 deletions(-) diff --git a/cli/yarn.lock b/cli/yarn.lock index c4ee83acc5..25fc3104fc 100644 --- a/cli/yarn.lock +++ b/cli/yarn.lock @@ -3414,19 +3414,10 @@ json-stable-stringify-without-jsonify@^1.0.1: resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651" integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE= -json5@^2.1.0: - version "2.1.1" - resolved "https://registry.yarnpkg.com/json5/-/json5-2.1.1.tgz#81b6cb04e9ba496f1c7005d07b4368a2638f90b6" - integrity sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ== - dependencies: - minimist "^1.2.0" - -json5@^2.1.2: - version "2.2.0" - resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3" - integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA== - dependencies: - minimist "^1.2.5" +json5@^2.1.0, json5@^2.1.2: + version "2.2.3" + resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" + integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== jsonfile@^4.0.0: version "4.0.0" @@ -3590,11 +3581,6 @@ minimatch@^3.0.4: dependencies: brace-expansion "^1.1.7" -minimist@^1.2.0, minimist@^1.2.5: - version "1.2.6" - resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44" - integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q== - mkdirp@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.3.tgz#4cf2e30ad45959dddea53ad97d518b6c8205e1ea" From 61b062d163654acd58ed174bf96fc6ea04c72c42 Mon Sep 17 00:00:00 2001 From: David Epely Date: Mon, 30 Jan 2023 20:57:36 +0100 Subject: [PATCH 5/7] [react-router-dom] fix & add missing hook definition (#4417) * [react-router-dom@v6.x.x] Fix tests for latest versions of flow (>= 0.191.x) * [react-router-dom@v6.x.x] add missing hook definition `useMatches` * [react-router-dom] export `Params` type --- .../flow_v0.104.x-/react-router-dom_v6.x.x.js | 10 ++- .../flow_v0.104.x-/test_react-router-dom.js | 75 +++++++++++++++++-- 2 files changed, 76 insertions(+), 9 deletions(-) diff --git a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js index 87f0e272bf..5566ac253a 100644 --- a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js +++ b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js @@ -201,7 +201,7 @@ declare module "react-router-dom" { children: React$Node, ): Array; - declare type Params = { + declare export type Params = { +[key: Key]: string | void; }; @@ -261,6 +261,14 @@ declare module "react-router-dom" { pattern: PathPattern | string ): PathMatch | null; + declare export function useMatches(): Array<{| + id: string; + pathname: string; + params: Params; + data: Data; + handle: Handle; + |}>; + declare export function useOutlet(): React$Element | null; declare export function useRoutes( diff --git a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js index 77d633af63..c03d806897 100644 --- a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js +++ b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js @@ -17,6 +17,7 @@ import { useOutletContext, useParams, useRouteMatch, + useMatches, } from "react-router-dom"; import type { Location, @@ -24,6 +25,7 @@ import type { Match, StaticRouterContext, RouterHistory, + Params, } from "react-router-dom"; import { it, describe } from "flow-typed-test"; @@ -272,7 +274,7 @@ describe("react-router-dom", () => { describe("Class Components", () => { it("passes if the component is passed required props", () => { class Comp extends React.Component { - render() { + render(): React$Element<'div'> { return
; } } @@ -285,7 +287,7 @@ describe("react-router-dom", () => { it("errors if the component is not passed the correct props", () => { class Comp extends React.Component { - render() { + render(): React$Element<'div'> { return
; } } @@ -303,11 +305,15 @@ describe("react-router-dom", () => { }); it("passes if a required prop is handled by defaultProps", () => { + type OwnProps = {| + s: string, + |}; + class Comp extends React.Component { - static defaultProps = { + static defaultProps: OwnProps = { s: "defaultS" }; - render() { + render(): React$Element<'div'> { return
; } } @@ -321,11 +327,15 @@ describe("react-router-dom", () => { }); it("errors if a required prop that has a defaultProp is passed the wrong type", () => { + type OwnProps = {| + s: string, + |}; + class Comp extends React.Component { - static defaultProps = { + static defaultProps: OwnProps = { s: "defaultS" }; - render() { + render(): React$Element<'div'> { return
; } } @@ -389,7 +399,7 @@ describe("react-router-dom", () => { describe("Route", () => { it("works", () => { - const Component = ({}) =>
Hi!
; + const Component = () =>
Hi!
; ; } />; @@ -411,7 +421,7 @@ describe("react-router-dom", () => { describe('Routes', () => { it('works', () => { - const Component = ({}) =>
Hi!
; + const Component = () =>
Hi!
; } /> ; @@ -476,5 +486,54 @@ describe("react-router-dom", () => { sensitive: 'foo', }); }); + + it('useMatches', () => { + type Matches = Array<{| + id: string, + pathname: string, + params: Params, + data: mixed, + handle: {| + custom: string, + |}, + |}>; + const matches: Matches = useMatches(); + + type MatchesWithHandle = Array<{| + id: string, + pathname: string, + params: Params, + data: mixed, + handle: {| + custom: string, + |}, + |}>; + const matchesWithHandle: MatchesWithHandle = useMatches< + mixed, + {| + custom: string, + |} + >(); + + type InvalidMatchesMissingPathname = Array<{| + id: string, + params: Params, + data: mixed, + handle: mixed, + |}>; + // $FlowExpectedError[prop-missing] + const matchesMissingPathname: InvalidMatchesMissingPathname = useMatches(); + + type InvalidMatchesIcompatibleParams = Array<{| + id: string, + pathname: string, + params: Params, + data: mixed, + handle: mixed, + |}>; + + // $FlowExpectedError[incompatible-type-arg] + const matchesIncompatibleParams: InvalidMatchesIcompatibleParams = useMatches(); + }); }); }); From b6ecf2d3de54959a5688806bd4874693ef00ac80 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 3 Feb 2023 11:05:12 -0500 Subject: [PATCH 6/7] Bump http-cache-semantics from 4.0.4 to 4.1.1 in /cli (#4420) Bumps [http-cache-semantics](https://github.com/kornelski/http-cache-semantics) from 4.0.4 to 4.1.1. - [Release notes](https://github.com/kornelski/http-cache-semantics/releases) - [Commits](https://github.com/kornelski/http-cache-semantics/compare/v4.0.4...v4.1.1) --- updated-dependencies: - dependency-name: http-cache-semantics dependency-type: indirect ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- cli/yarn.lock | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cli/yarn.lock b/cli/yarn.lock index 25fc3104fc..65d5b6e344 100644 --- a/cli/yarn.lock +++ b/cli/yarn.lock @@ -2689,9 +2689,9 @@ html-escaper@^2.0.0: integrity sha512-a4u9BeERWGu/S8JiWEAQcdrg9v4QArtP9keViQjGMdff20fBdd8waotXaNmODqBe6uZ3Nafi7K/ho4gCQHV3Ig== http-cache-semantics@^4.0.0: - version "4.0.4" - resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz#13eeb612424bb113d52172c28a13109c46fa85d7" - integrity sha512-Z2EICWNJou7Tr9Bd2M2UqDJq3A9F2ePG9w3lIpjoyuSyXFP9QbniJVu3XQYytuw5ebmG7dXSXO9PgAjJG8DDKA== + version "4.1.1" + resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz#abe02fcb2985460bf0323be664436ec3476a6d5a" + integrity sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ== http-proxy-agent@^4.0.1: version "4.0.1" From d2cf93908dfb2678011c9bd63ef30c85c0a74747 Mon Sep 17 00:00:00 2001 From: David Epely Date: Mon, 6 Feb 2023 19:43:54 +0100 Subject: [PATCH 7/7] [react-router-dom] update Route component type (#4418) - Add missing props to Route component. - Import types from source code then adapt to flow. - update and fix Route component tests according to the changes. --- .../flow_v0.104.x-/react-router-dom_v6.x.x.js | 295 +++++++++++++++++- .../flow_v0.104.x-/test_react-router-dom.js | 49 ++- 2 files changed, 329 insertions(+), 15 deletions(-) diff --git a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js index 5566ac253a..c4f597ce4d 100644 --- a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js +++ b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/react-router-dom_v6.x.x.js @@ -125,13 +125,271 @@ declare module "react-router-dom" { children?: React$Node |}> - declare export var Route: React$ComponentType<{| - caseSensitive?: boolean, - children?: React$Node, - element?: React$Element | null, - index?: boolean, - path?: string, - |}> + declare export type ResultTypeData = 'data' + declare export type ResultTypeDeferred = 'deferred' + declare export type ResultTypeRedirect = 'redirect' + declare export type ResultTypeError = 'error' + + /** + * Successful result from a loader or action + */ + declare export type SuccessResult = {| + type: ResultTypeData; + data: any; + statusCode?: number; + headers?: Headers; + |} + + declare export class DeferredData { + (data: mixed, responseInit?: ResponseOptions): void; + subscribe: mixed, + cancel: mixed, + resolveData: mixed, + done: mixed, + unwrappedData: mixed, + pendingKeys: mixed, + } + + /** + * Successful defer() result from a loader or action + */ + declare export type DeferredResult = {| + type: ResultTypeDeferred; + deferredData: DeferredData; + statusCode?: number; + headers?: Headers; + |} + + /** + * Redirect result from a loader or action + */ + declare export type RedirectResult = {| + type: ResultTypeRedirect; + status: number; + location: string; + revalidate: boolean; + |} + + /** + * Unsuccessful result from a loader or action + */ + declare export type ErrorResult = {| + type: ResultTypeError; + error: any; + headers?: Headers; + |} + + /** + * Result from a loader or action - potentially successful or unsuccessful + */ + declare export type DataResult = + | SuccessResult + | DeferredResult + | RedirectResult + | ErrorResult; + + declare export type MutationFormMethod = "post" | "put" | "patch" | "delete"; + declare export type FormMethod = "get" | MutationFormMethod; + declare export type FormEncType = + | "application/x-www-form-urlencoded" + | "multipart/form-data"; + + /** + * @private + * Internal interface to pass around for action submissions, not intended for + * external consumption + */ + declare export type Submission = {| + formMethod: FormMethod; + formAction: string; + formEncType: FormEncType; + formData: FormData; + |} + + /** + * Index routes must not have children + */ + declare export type AgnosticIndexRouteObject = {| + ...AgnosticBaseRouteObject, + children?: void; + index: true; + |}; + + declare export type AgnosticDataIndexRouteObject = {| + ...AgnosticIndexRouteObject, + id: string; + |}; + + declare export type AgnosticNonIndexRouteObject = {| + ...AgnosticBaseRouteObject, + children?: AgnosticRouteObject[]; + index?: false; + |}; + + declare export type AgnosticDataNonIndexRouteObject = {| + ...AgnosticNonIndexRouteObject, + children?: AgnosticDataRouteObject[]; + id: string; + |}; + + /** + * A data route object, which is just a RouteObject with a required unique ID + */ + declare export type AgnosticDataRouteObject = + | AgnosticDataIndexRouteObject + | AgnosticDataNonIndexRouteObject; + + /** + * A route object represents a logical route, with (optionally) its child + * routes organized in a tree-like structure. + */ + declare export type AgnosticRouteObject = + | AgnosticIndexRouteObject + | AgnosticNonIndexRouteObject; + + /** + * A RouteMatch contains info about how a route matched a URL. + */ + declare export type AgnosticRouteMatch< + ParamKey: string = string, + RouteObjectType: AgnosticRouteObject = AgnosticRouteObject + > = {| + /** + * The names and values of dynamic parameters in the URL. + */ + params: Params; + /** + * The portion of the URL pathname that was matched. + */ + pathname: string; + /** + * The portion of the URL pathname that was matched before child routes. + */ + pathnameBase: string; + /** + * The route object that was used to match. + */ + route: RouteObjectType; + |} + + declare export type AgnosticDataRouteMatch = AgnosticRouteMatch; + + /** + * @private + * Arguments passed to route loader/action functions. Same for now but we keep + * this as a private implementation detail in case they diverge in the future. + */ + declare type DataFunctionArgs = {| + request: Request; + params: Params; + context?: any; + |} + + /** + * Arguments passed to loader functions + */ + declare export type LoaderFunctionArgs = DataFunctionArgs; + + + /** + * Arguments passed to action functions + */ + declare export type ActionFunctionArgs = DataFunctionArgs; + + /** + * Route loader function signature + */ + declare export type LoaderFunction = (args: LoaderFunctionArgs) => Promise | Response | Promise | any; + + /** + * Route action function signature + */ + declare export type ActionFunction = (args: ActionFunctionArgs) => Promise | Response | Promise | any; + + /** + * Route shouldRevalidate function signature. This runs after any submission + * (navigation or fetcher), so we flatten the navigation/fetcher submission + * onto the arguments. It shouldn't matter whether it came from a navigation + * or a fetcher, what really matters is the URLs and the formData since loaders + * have to re-run based on the data models that were potentially mutated. + */ + declare export type ShouldRevalidateFunction = (args: {| + currentUrl: URL; + currentParams: AgnosticDataRouteMatch["params"]; + nextUrl: URL; + nextParams: AgnosticDataRouteMatch["params"]; + formMethod?: Submission["formMethod"]; + formAction?: Submission["formAction"]; + formEncType?: Submission["formEncType"]; + formData?: Submission["formData"]; + actionResult?: DataResult; + defaultShouldRevalidate: boolean; + |}) => boolean; + + /** + * Base RouteObject with common props shared by all types of routes + */ + declare type AgnosticBaseRouteObject = {| + caseSensitive?: boolean; + path?: string; + id?: string; + loader?: LoaderFunction; + action?: ActionFunction; + hasErrorBoundary?: boolean; + shouldRevalidate?: ShouldRevalidateFunction; + handle?: mixed; + |}; + + declare export type NonIndexRouteObject = {| + caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"]; + path?: AgnosticNonIndexRouteObject["path"]; + id?: AgnosticNonIndexRouteObject["id"]; + loader?: AgnosticNonIndexRouteObject["loader"]; + action?: AgnosticNonIndexRouteObject["action"]; + hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"]; + shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"]; + handle?: AgnosticNonIndexRouteObject["handle"]; + index?: false; + children?: RouteObject[]; + element?: React$Node | null; + errorElement?: React$Node | null; + |} + + declare export type PathRouteProps = {| + caseSensitive?: NonIndexRouteObject["caseSensitive"]; + path?: NonIndexRouteObject["path"]; + id?: NonIndexRouteObject["id"]; + loader?: NonIndexRouteObject["loader"]; + action?: NonIndexRouteObject["action"]; + hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"]; + shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"]; + handle?: NonIndexRouteObject["handle"]; + index?: false; + children?: React$Node; + element?: React$Node | null; + errorElement?: React$Node | null; + |} + + declare export type LayoutRouteProps = PathRouteProps + + declare export type IndexRouteProps = {| + caseSensitive?: IndexRouteObject["caseSensitive"]; + path?: IndexRouteObject["path"]; + id?: IndexRouteObject["id"]; + loader?: IndexRouteObject["loader"]; + action?: IndexRouteObject["action"]; + hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"]; + shouldRevalidate?: IndexRouteObject["shouldRevalidate"]; + handle?: IndexRouteObject["handle"]; + index: true; + children?: void; + element?: React$Node | null; + errorElement?: React$Node | null; + |} + + declare export type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps; + + declare export var Route: React$ComponentType declare export var Prompt: React$ComponentType<{| message: string | ((location: Location) => string | boolean), @@ -189,13 +447,22 @@ declare module "react-router-dom" { declare export function generatePath(pattern?: string, params?: { +[string]: mixed, ... }): string; - declare type RouteObject = {| - caseSensitive?: boolean, - children?: Array, - element?: React$Node, - index?: boolean, - path?: string, - |}; + declare export type IndexRouteObject = {| + caseSensitive?: AgnosticIndexRouteObject["caseSensitive"]; + path?: AgnosticIndexRouteObject["path"]; + id?: AgnosticIndexRouteObject["id"]; + loader?: AgnosticIndexRouteObject["loader"]; + action?: AgnosticIndexRouteObject["action"]; + hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"]; + shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"]; + handle?: AgnosticIndexRouteObject["handle"]; + index: true; + children?: void; + element?: React$Node | null; + errorElement?: React$Node | null; + |} + + declare export type RouteObject = IndexRouteObject | NonIndexRouteObject; declare export function createRoutesFromChildren( children: React$Node, diff --git a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js index c03d806897..e99567a96e 100644 --- a/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js +++ b/definitions/npm/react-router-dom_v6.x.x/flow_v0.104.x-/test_react-router-dom.js @@ -408,14 +408,61 @@ describe("react-router-dom", () => { index caseSensitive />; + +
Hi!
; + + { + const myRequest: Request = request; + const myParams: Params = params; + }} + action={() => {}} + hasErrorBoundary + shouldRevalidate={() => false} + handle={{ breadcrumb: 'login'}} + index={false} + element={} + errorElement={} + />; }); it("raises error if passed incorrect props", () => { // $FlowExpectedError[incompatible-type] - prop must be a string ; - // $FlowExpectedError[prop-missing] - unexpected prop xxx + // $FlowExpectedError[incompatible-type] - unexpected prop xxx ; + + // $FlowExpectedError[incompatible-type] + true} />; + + // $FlowExpectedError[incompatible-type] + ; + + { + // $FlowExpectedError[incompatible-type] + const myRequest: string = request; + + // $FlowExpectedError[incompatible-type] + const myParams: string = params; + + // $FlowExpectedError[prop-missing] + const missing: any = loaderArgs.missing; + + return false; + }} />; + + // $FlowExpectedError[incompatible-type] + ; + + // $FlowExpectedError[incompatible-type] + true} />; + + // $FlowExpectedError[incompatible-type] + ; }); });