stellate 1.30.0 → 1.31.0

package/dist/apollo-server.d.ts

@@ -0,0 +1,4411 @@
+interface Logger {
+    debug(message?: any): void;
+    info(message?: any): void;
+    warn(message?: any): void;
+    error(message?: any): void;
+}
+
+/** Conveniently represents flow's "Maybe" type https://flow.org/en/docs/types/maybe/ */
+declare type Maybe<T> = null | undefined | T;
+
+interface Location$1 {
+  line: number;
+  column: number;
+}
+/**
+ * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are
+ * optional, but they are useful for clients who store GraphQL documents in source files.
+ * For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might
+ * be useful for `name` to be `"Foo.graphql"` and location to be `{ line: 40, column: 1 }`.
+ * The `line` and `column` properties in `locationOffset` are 1-indexed.
+ */
+declare class Source {
+  body: string;
+  name: string;
+  locationOffset: Location$1;
+  constructor(body: string, name?: string, locationOffset?: Location$1);
+  get [Symbol.toStringTag](): string;
+}
+
+interface ObjMap$1<T> {
+  [key: string]: T;
+}
+
+interface Path {
+  readonly prev: Path | undefined;
+  readonly key: string | number;
+  readonly typename: string | undefined;
+}
+
+declare type PromiseOrValue<T> = Promise<T> | T;
+
+/**
+ * The set of allowed kind values for AST nodes.
+ */
+declare enum Kind {
+  /** Name */
+  NAME = 'Name',
+  /** Document */
+  DOCUMENT = 'Document',
+  OPERATION_DEFINITION = 'OperationDefinition',
+  VARIABLE_DEFINITION = 'VariableDefinition',
+  SELECTION_SET = 'SelectionSet',
+  FIELD = 'Field',
+  ARGUMENT = 'Argument',
+  /** Fragments */
+  FRAGMENT_SPREAD = 'FragmentSpread',
+  INLINE_FRAGMENT = 'InlineFragment',
+  FRAGMENT_DEFINITION = 'FragmentDefinition',
+  /** Values */
+  VARIABLE = 'Variable',
+  INT = 'IntValue',
+  FLOAT = 'FloatValue',
+  STRING = 'StringValue',
+  BOOLEAN = 'BooleanValue',
+  NULL = 'NullValue',
+  ENUM = 'EnumValue',
+  LIST = 'ListValue',
+  OBJECT = 'ObjectValue',
+  OBJECT_FIELD = 'ObjectField',
+  /** Directives */
+  DIRECTIVE = 'Directive',
+  /** Types */
+  NAMED_TYPE = 'NamedType',
+  LIST_TYPE = 'ListType',
+  NON_NULL_TYPE = 'NonNullType',
+  /** Type System Definitions */
+  SCHEMA_DEFINITION = 'SchemaDefinition',
+  OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition',
+  /** Type Definitions */
+  SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition',
+  OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition',
+  FIELD_DEFINITION = 'FieldDefinition',
+  INPUT_VALUE_DEFINITION = 'InputValueDefinition',
+  INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition',
+  UNION_TYPE_DEFINITION = 'UnionTypeDefinition',
+  ENUM_TYPE_DEFINITION = 'EnumTypeDefinition',
+  ENUM_VALUE_DEFINITION = 'EnumValueDefinition',
+  INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition',
+  /** Directive Definitions */
+  DIRECTIVE_DEFINITION = 'DirectiveDefinition',
+  /** Type System Extensions */
+  SCHEMA_EXTENSION = 'SchemaExtension',
+  /** Type Extensions */
+  SCALAR_TYPE_EXTENSION = 'ScalarTypeExtension',
+  OBJECT_TYPE_EXTENSION = 'ObjectTypeExtension',
+  INTERFACE_TYPE_EXTENSION = 'InterfaceTypeExtension',
+  UNION_TYPE_EXTENSION = 'UnionTypeExtension',
+  ENUM_TYPE_EXTENSION = 'EnumTypeExtension',
+  INPUT_OBJECT_TYPE_EXTENSION = 'InputObjectTypeExtension',
+}
+
+/**
+ * An exported enum describing the different kinds of tokens that the
+ * lexer emits.
+ */
+declare enum TokenKind {
+  SOF = '<SOF>',
+  EOF = '<EOF>',
+  BANG = '!',
+  DOLLAR = '$',
+  AMP = '&',
+  PAREN_L = '(',
+  PAREN_R = ')',
+  SPREAD = '...',
+  COLON = ':',
+  EQUALS = '=',
+  AT = '@',
+  BRACKET_L = '[',
+  BRACKET_R = ']',
+  BRACE_L = '{',
+  PIPE = '|',
+  BRACE_R = '}',
+  NAME = 'Name',
+  INT = 'Int',
+  FLOAT = 'Float',
+  STRING = 'String',
+  BLOCK_STRING = 'BlockString',
+  COMMENT = 'Comment',
+}
+
+/**
+ * Contains a range of UTF-8 character offsets and token references that
+ * identify the region of the source from which the AST derived.
+ */
+declare class Location {
+  /**
+   * The character offset at which this Node begins.
+   */
+  readonly start: number;
+  /**
+   * The character offset at which this Node ends.
+   */
+  readonly end: number;
+  /**
+   * The Token at which this Node begins.
+   */
+  readonly startToken: Token;
+  /**
+   * The Token at which this Node ends.
+   */
+  readonly endToken: Token;
+  /**
+   * The Source document the AST represents.
+   */
+  readonly source: Source;
+  constructor(startToken: Token, endToken: Token, source: Source);
+  get [Symbol.toStringTag](): string;
+  toJSON(): {
+    start: number;
+    end: number;
+  };
+}
+/**
+ * Represents a range of characters represented by a lexical token
+ * within a Source.
+ */
+declare class Token {
+  /**
+   * The kind of Token.
+   */
+  readonly kind: TokenKind;
+  /**
+   * The character offset at which this Node begins.
+   */
+  readonly start: number;
+  /**
+   * The character offset at which this Node ends.
+   */
+  readonly end: number;
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+  readonly line: number;
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+  readonly column: number;
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   *
+   * Note: is undefined for punctuation tokens, but typed as string for
+   * convenience in the parser.
+   */
+  readonly value: string;
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  readonly prev: Token | null;
+  readonly next: Token | null;
+  constructor(
+    kind: TokenKind,
+    start: number,
+    end: number,
+    line: number,
+    column: number,
+    value?: string,
+  );
+  get [Symbol.toStringTag](): string;
+  toJSON(): {
+    kind: TokenKind;
+    value?: string;
+    line: number;
+    column: number;
+  };
+}
+/**
+ * The list of all possible AST node types.
+ */
+declare type ASTNode =
+  | NameNode
+  | DocumentNode
+  | OperationDefinitionNode
+  | VariableDefinitionNode
+  | VariableNode
+  | SelectionSetNode
+  | FieldNode
+  | ArgumentNode
+  | FragmentSpreadNode
+  | InlineFragmentNode
+  | FragmentDefinitionNode
+  | IntValueNode
+  | FloatValueNode
+  | StringValueNode
+  | BooleanValueNode
+  | NullValueNode
+  | EnumValueNode
+  | ListValueNode
+  | ObjectValueNode
+  | ObjectFieldNode
+  | DirectiveNode
+  | NamedTypeNode
+  | ListTypeNode
+  | NonNullTypeNode
+  | SchemaDefinitionNode
+  | OperationTypeDefinitionNode
+  | ScalarTypeDefinitionNode
+  | ObjectTypeDefinitionNode
+  | FieldDefinitionNode
+  | InputValueDefinitionNode
+  | InterfaceTypeDefinitionNode
+  | UnionTypeDefinitionNode
+  | EnumTypeDefinitionNode
+  | EnumValueDefinitionNode
+  | InputObjectTypeDefinitionNode
+  | DirectiveDefinitionNode
+  | SchemaExtensionNode
+  | ScalarTypeExtensionNode
+  | ObjectTypeExtensionNode
+  | InterfaceTypeExtensionNode
+  | UnionTypeExtensionNode
+  | EnumTypeExtensionNode
+  | InputObjectTypeExtensionNode;
+/** Name */
+interface NameNode {
+  readonly kind: Kind.NAME;
+  readonly loc?: Location;
+  readonly value: string;
+}
+/** Document */
+interface DocumentNode {
+  readonly kind: Kind.DOCUMENT;
+  readonly loc?: Location;
+  readonly definitions: ReadonlyArray<DefinitionNode>;
+}
+declare type DefinitionNode =
+  | ExecutableDefinitionNode
+  | TypeSystemDefinitionNode
+  | TypeSystemExtensionNode;
+declare type ExecutableDefinitionNode =
+  | OperationDefinitionNode
+  | FragmentDefinitionNode;
+interface OperationDefinitionNode {
+  readonly kind: Kind.OPERATION_DEFINITION;
+  readonly loc?: Location;
+  readonly operation: OperationTypeNode;
+  readonly name?: NameNode;
+  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
+  readonly directives?: ReadonlyArray<DirectiveNode>;
+  readonly selectionSet: SelectionSetNode;
+}
+declare enum OperationTypeNode {
+  QUERY = 'query',
+  MUTATION = 'mutation',
+  SUBSCRIPTION = 'subscription',
+}
+
+interface VariableDefinitionNode {
+  readonly kind: Kind.VARIABLE_DEFINITION;
+  readonly loc?: Location;
+  readonly variable: VariableNode;
+  readonly type: TypeNode;
+  readonly defaultValue?: ConstValueNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface VariableNode {
+  readonly kind: Kind.VARIABLE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+}
+interface SelectionSetNode {
+  kind: Kind.SELECTION_SET;
+  loc?: Location;
+  selections: ReadonlyArray<SelectionNode>;
+}
+declare type SelectionNode =
+  | FieldNode
+  | FragmentSpreadNode
+  | InlineFragmentNode;
+interface FieldNode {
+  readonly kind: Kind.FIELD;
+  readonly loc?: Location;
+  readonly alias?: NameNode;
+  readonly name: NameNode;
+  readonly arguments?: ReadonlyArray<ArgumentNode>;
+  readonly directives?: ReadonlyArray<DirectiveNode>;
+  readonly selectionSet?: SelectionSetNode;
+}
+interface ArgumentNode {
+  readonly kind: Kind.ARGUMENT;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly value: ValueNode;
+}
+interface ConstArgumentNode {
+  readonly kind: Kind.ARGUMENT;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly value: ConstValueNode;
+}
+/** Fragments */
+interface FragmentSpreadNode {
+  readonly kind: Kind.FRAGMENT_SPREAD;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<DirectiveNode>;
+}
+interface InlineFragmentNode {
+  readonly kind: Kind.INLINE_FRAGMENT;
+  readonly loc?: Location;
+  readonly typeCondition?: NamedTypeNode;
+  readonly directives?: ReadonlyArray<DirectiveNode>;
+  readonly selectionSet: SelectionSetNode;
+}
+interface FragmentDefinitionNode {
+  readonly kind: Kind.FRAGMENT_DEFINITION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  /** @deprecated variableDefinitions will be removed in v17.0.0 */
+  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
+  readonly typeCondition: NamedTypeNode;
+  readonly directives?: ReadonlyArray<DirectiveNode>;
+  readonly selectionSet: SelectionSetNode;
+}
+/** Values */
+declare type ValueNode =
+  | VariableNode
+  | IntValueNode
+  | FloatValueNode
+  | StringValueNode
+  | BooleanValueNode
+  | NullValueNode
+  | EnumValueNode
+  | ListValueNode
+  | ObjectValueNode;
+declare type ConstValueNode =
+  | IntValueNode
+  | FloatValueNode
+  | StringValueNode
+  | BooleanValueNode
+  | NullValueNode
+  | EnumValueNode
+  | ConstListValueNode
+  | ConstObjectValueNode;
+interface IntValueNode {
+  readonly kind: Kind.INT;
+  readonly loc?: Location;
+  readonly value: string;
+}
+interface FloatValueNode {
+  readonly kind: Kind.FLOAT;
+  readonly loc?: Location;
+  readonly value: string;
+}
+interface StringValueNode {
+  readonly kind: Kind.STRING;
+  readonly loc?: Location;
+  readonly value: string;
+  readonly block?: boolean;
+}
+interface BooleanValueNode {
+  readonly kind: Kind.BOOLEAN;
+  readonly loc?: Location;
+  readonly value: boolean;
+}
+interface NullValueNode {
+  readonly kind: Kind.NULL;
+  readonly loc?: Location;
+}
+interface EnumValueNode {
+  readonly kind: Kind.ENUM;
+  readonly loc?: Location;
+  readonly value: string;
+}
+interface ListValueNode {
+  readonly kind: Kind.LIST;
+  readonly loc?: Location;
+  readonly values: ReadonlyArray<ValueNode>;
+}
+interface ConstListValueNode {
+  readonly kind: Kind.LIST;
+  readonly loc?: Location;
+  readonly values: ReadonlyArray<ConstValueNode>;
+}
+interface ObjectValueNode {
+  readonly kind: Kind.OBJECT;
+  readonly loc?: Location;
+  readonly fields: ReadonlyArray<ObjectFieldNode>;
+}
+interface ConstObjectValueNode {
+  readonly kind: Kind.OBJECT;
+  readonly loc?: Location;
+  readonly fields: ReadonlyArray<ConstObjectFieldNode>;
+}
+interface ObjectFieldNode {
+  readonly kind: Kind.OBJECT_FIELD;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly value: ValueNode;
+}
+interface ConstObjectFieldNode {
+  readonly kind: Kind.OBJECT_FIELD;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly value: ConstValueNode;
+}
+/** Directives */
+interface DirectiveNode {
+  readonly kind: Kind.DIRECTIVE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly arguments?: ReadonlyArray<ArgumentNode>;
+}
+interface ConstDirectiveNode {
+  readonly kind: Kind.DIRECTIVE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly arguments?: ReadonlyArray<ConstArgumentNode>;
+}
+/** Type Reference */
+declare type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
+interface NamedTypeNode {
+  readonly kind: Kind.NAMED_TYPE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+}
+interface ListTypeNode {
+  readonly kind: Kind.LIST_TYPE;
+  readonly loc?: Location;
+  readonly type: TypeNode;
+}
+interface NonNullTypeNode {
+  readonly kind: Kind.NON_NULL_TYPE;
+  readonly loc?: Location;
+  readonly type: NamedTypeNode | ListTypeNode;
+}
+/** Type System Definition */
+declare type TypeSystemDefinitionNode =
+  | SchemaDefinitionNode
+  | TypeDefinitionNode
+  | DirectiveDefinitionNode;
+interface SchemaDefinitionNode {
+  readonly kind: Kind.SCHEMA_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
+}
+interface OperationTypeDefinitionNode {
+  readonly kind: Kind.OPERATION_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly operation: OperationTypeNode;
+  readonly type: NamedTypeNode;
+}
+/** Type Definition */
+declare type TypeDefinitionNode =
+  | ScalarTypeDefinitionNode
+  | ObjectTypeDefinitionNode
+  | InterfaceTypeDefinitionNode
+  | UnionTypeDefinitionNode
+  | EnumTypeDefinitionNode
+  | InputObjectTypeDefinitionNode;
+interface ScalarTypeDefinitionNode {
+  readonly kind: Kind.SCALAR_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface ObjectTypeDefinitionNode {
+  readonly kind: Kind.OBJECT_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface FieldDefinitionNode {
+  readonly kind: Kind.FIELD_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
+  readonly type: TypeNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface InputValueDefinitionNode {
+  readonly kind: Kind.INPUT_VALUE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly type: TypeNode;
+  readonly defaultValue?: ConstValueNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface InterfaceTypeDefinitionNode {
+  readonly kind: Kind.INTERFACE_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface UnionTypeDefinitionNode {
+  readonly kind: Kind.UNION_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly types?: ReadonlyArray<NamedTypeNode>;
+}
+interface EnumTypeDefinitionNode {
+  readonly kind: Kind.ENUM_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
+}
+interface EnumValueDefinitionNode {
+  readonly kind: Kind.ENUM_VALUE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface InputObjectTypeDefinitionNode {
+  readonly kind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
+}
+/** Directive Definitions */
+interface DirectiveDefinitionNode {
+  readonly kind: Kind.DIRECTIVE_DEFINITION;
+  readonly loc?: Location;
+  readonly description?: StringValueNode;
+  readonly name: NameNode;
+  readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
+  readonly repeatable: boolean;
+  readonly locations: ReadonlyArray<NameNode>;
+}
+/** Type System Extensions */
+declare type TypeSystemExtensionNode =
+  | SchemaExtensionNode
+  | TypeExtensionNode;
+interface SchemaExtensionNode {
+  readonly kind: Kind.SCHEMA_EXTENSION;
+  readonly loc?: Location;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
+}
+/** Type Extensions */
+declare type TypeExtensionNode =
+  | ScalarTypeExtensionNode
+  | ObjectTypeExtensionNode
+  | InterfaceTypeExtensionNode
+  | UnionTypeExtensionNode
+  | EnumTypeExtensionNode
+  | InputObjectTypeExtensionNode;
+interface ScalarTypeExtensionNode {
+  readonly kind: Kind.SCALAR_TYPE_EXTENSION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface ObjectTypeExtensionNode {
+  readonly kind: Kind.OBJECT_TYPE_EXTENSION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface InterfaceTypeExtensionNode {
+  readonly kind: Kind.INTERFACE_TYPE_EXTENSION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly interfaces?: ReadonlyArray<NamedTypeNode>;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly fields?: ReadonlyArray<FieldDefinitionNode>;
+}
+interface UnionTypeExtensionNode {
+  readonly kind: Kind.UNION_TYPE_EXTENSION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly types?: ReadonlyArray<NamedTypeNode>;
+}
+interface EnumTypeExtensionNode {
+  readonly kind: Kind.ENUM_TYPE_EXTENSION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
+}
+interface InputObjectTypeExtensionNode {
+  readonly kind: Kind.INPUT_OBJECT_TYPE_EXTENSION;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+  readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
+}
+
+/**
+ * Represents a location in a Source.
+ */
+interface SourceLocation {
+  readonly line: number;
+  readonly column: number;
+}
+
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLErrorExtensions {
+  [attributeName: string]: unknown;
+}
+interface GraphQLErrorOptions {
+  nodes?: ReadonlyArray<ASTNode> | ASTNode | null;
+  source?: Maybe<Source>;
+  positions?: Maybe<ReadonlyArray<number>>;
+  path?: Maybe<ReadonlyArray<string | number>>;
+  originalError?: Maybe<
+    Error & {
+      readonly extensions?: unknown;
+    }
+  >;
+  extensions?: Maybe<GraphQLErrorExtensions>;
+}
+/**
+ * A GraphQLError describes an Error found during the parse, validate, or
+ * execute phases of performing a GraphQL operation. In addition to a message
+ * and stack trace, it also includes information about the locations in a
+ * GraphQL document and/or execution result that correspond to the Error.
+ */
+declare class GraphQLError extends Error {
+  /**
+   * An array of `{ line, column }` locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  readonly locations: ReadonlyArray<SourceLocation> | undefined;
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  readonly path: ReadonlyArray<string | number> | undefined;
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+  readonly nodes: ReadonlyArray<ASTNode> | undefined;
+  /**
+   * The source GraphQL document for the first location of this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+  readonly source: Source | undefined;
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+  readonly positions: ReadonlyArray<number> | undefined;
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+  readonly originalError: Error | undefined;
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  readonly extensions: GraphQLErrorExtensions;
+  constructor(message: string, options?: GraphQLErrorOptions);
+  /**
+   * @deprecated Please use the `GraphQLErrorOptions` constructor overload instead.
+   */
+  constructor(
+    message: string,
+    nodes?: ReadonlyArray<ASTNode> | ASTNode | null,
+    source?: Maybe<Source>,
+    positions?: Maybe<ReadonlyArray<number>>,
+    path?: Maybe<ReadonlyArray<string | number>>,
+    originalError?: Maybe<
+      Error & {
+        readonly extensions?: unknown;
+      }
+    >,
+    extensions?: Maybe<GraphQLErrorExtensions>,
+  );
+  get [Symbol.toStringTag](): string;
+  toString(): string;
+  toJSON(): GraphQLFormattedError;
+}
+/**
+ * See: https://spec.graphql.org/draft/#sec-Errors
+ */
+interface GraphQLFormattedError {
+  /**
+   * A short, human-readable summary of the problem that **SHOULD NOT** change
+   * from occurrence to occurrence of the problem, except for purposes of
+   * localization.
+   */
+  readonly message: string;
+  /**
+   * If an error can be associated to a particular point in the requested
+   * GraphQL document, it should contain a list of locations.
+   */
+  readonly locations?: ReadonlyArray<SourceLocation>;
+  /**
+   * If an error can be associated to a particular field in the GraphQL result,
+   * it _must_ contain an entry with the key `path` that details the path of
+   * the response field which experienced the error. This allows clients to
+   * identify whether a null result is intentional or caused by a runtime error.
+   */
+  readonly path?: ReadonlyArray<string | number>;
+  /**
+   * Reserved for implementors to extend the protocol however they see fit,
+   * and hence there are no additional restrictions on its contents.
+   */
+  readonly extensions?: {
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * The set of allowed directive location values.
+ */
+declare enum DirectiveLocation {
+  /** Request Definitions */
+  QUERY = 'QUERY',
+  MUTATION = 'MUTATION',
+  SUBSCRIPTION = 'SUBSCRIPTION',
+  FIELD = 'FIELD',
+  FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION',
+  FRAGMENT_SPREAD = 'FRAGMENT_SPREAD',
+  INLINE_FRAGMENT = 'INLINE_FRAGMENT',
+  VARIABLE_DEFINITION = 'VARIABLE_DEFINITION',
+  /** Type System Definitions */
+  SCHEMA = 'SCHEMA',
+  SCALAR = 'SCALAR',
+  OBJECT = 'OBJECT',
+  FIELD_DEFINITION = 'FIELD_DEFINITION',
+  ARGUMENT_DEFINITION = 'ARGUMENT_DEFINITION',
+  INTERFACE = 'INTERFACE',
+  UNION = 'UNION',
+  ENUM = 'ENUM',
+  ENUM_VALUE = 'ENUM_VALUE',
+  INPUT_OBJECT = 'INPUT_OBJECT',
+  INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION',
+}
+
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLDirectiveExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Directives are used by the GraphQL runtime as a way of modifying execution
+ * behavior. Type system creators will usually not create these directly.
+ */
+declare class GraphQLDirective {
+  name: string;
+  description: Maybe<string>;
+  locations: ReadonlyArray<DirectiveLocation>;
+  args: ReadonlyArray<GraphQLArgument>;
+  isRepeatable: boolean;
+  extensions: Readonly<GraphQLDirectiveExtensions>;
+  astNode: Maybe<DirectiveDefinitionNode>;
+  constructor(config: Readonly<GraphQLDirectiveConfig>);
+  get [Symbol.toStringTag](): string;
+  toConfig(): GraphQLDirectiveNormalizedConfig;
+  toString(): string;
+  toJSON(): string;
+}
+interface GraphQLDirectiveConfig {
+  name: string;
+  description?: Maybe<string>;
+  locations: ReadonlyArray<DirectiveLocation>;
+  args?: Maybe<GraphQLFieldConfigArgumentMap>;
+  isRepeatable?: Maybe<boolean>;
+  extensions?: Maybe<Readonly<GraphQLDirectiveExtensions>>;
+  astNode?: Maybe<DirectiveDefinitionNode>;
+}
+interface GraphQLDirectiveNormalizedConfig extends GraphQLDirectiveConfig {
+  args: GraphQLFieldConfigArgumentMap;
+  isRepeatable: boolean;
+  extensions: Readonly<GraphQLDirectiveExtensions>;
+}
+
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLSchemaExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Schema Definition
+ *
+ * A Schema is created by supplying the root types of each type of operation,
+ * query and mutation (optional). A schema definition is then supplied to the
+ * validator and executor.
+ *
+ * Example:
+ *
+ * ```ts
+ * const MyAppSchema = new GraphQLSchema({
+ *   query: MyAppQueryRootType,
+ *   mutation: MyAppMutationRootType,
+ * })
+ * ```
+ *
+ * Note: When the schema is constructed, by default only the types that are
+ * reachable by traversing the root types are included, other types must be
+ * explicitly referenced.
+ *
+ * Example:
+ *
+ * ```ts
+ * const characterInterface = new GraphQLInterfaceType({
+ *   name: 'Character',
+ *   ...
+ * });
+ *
+ * const humanType = new GraphQLObjectType({
+ *   name: 'Human',
+ *   interfaces: [characterInterface],
+ *   ...
+ * });
+ *
+ * const droidType = new GraphQLObjectType({
+ *   name: 'Droid',
+ *   interfaces: [characterInterface],
+ *   ...
+ * });
+ *
+ * const schema = new GraphQLSchema({
+ *   query: new GraphQLObjectType({
+ *     name: 'Query',
+ *     fields: {
+ *       hero: { type: characterInterface, ... },
+ *     }
+ *   }),
+ *   ...
+ *   // Since this schema references only the `Character` interface it's
+ *   // necessary to explicitly list the types that implement it if
+ *   // you want them to be included in the final schema.
+ *   types: [humanType, droidType],
+ * })
+ * ```
+ *
+ * Note: If an array of `directives` are provided to GraphQLSchema, that will be
+ * the exact list of directives represented and allowed. If `directives` is not
+ * provided then a default set of the specified directives (e.g. `@include` and
+ * `@skip`) will be used. If you wish to provide *additional* directives to these
+ * specified directives, you must explicitly declare them. Example:
+ *
+ * ```ts
+ * const MyAppSchema = new GraphQLSchema({
+ *   ...
+ *   directives: specifiedDirectives.concat([ myCustomDirective ]),
+ * })
+ * ```
+ */
+declare class GraphQLSchema {
+  description: Maybe<string>;
+  extensions: Readonly<GraphQLSchemaExtensions>;
+  astNode: Maybe<SchemaDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<SchemaExtensionNode>;
+  __validationErrors: Maybe<ReadonlyArray<GraphQLError>>;
+  private _queryType;
+  private _mutationType;
+  private _subscriptionType;
+  private _directives;
+  private _typeMap;
+  private _subTypeMap;
+  private _implementationsMap;
+  constructor(config: Readonly<GraphQLSchemaConfig>);
+  get [Symbol.toStringTag](): string;
+  getQueryType(): Maybe<GraphQLObjectType>;
+  getMutationType(): Maybe<GraphQLObjectType>;
+  getSubscriptionType(): Maybe<GraphQLObjectType>;
+  getRootType(operation: OperationTypeNode): Maybe<GraphQLObjectType>;
+  getTypeMap(): TypeMap;
+  getType(name: string): GraphQLNamedType | undefined;
+  getPossibleTypes(
+    abstractType: GraphQLAbstractType,
+  ): ReadonlyArray<GraphQLObjectType>;
+  getImplementations(interfaceType: GraphQLInterfaceType): {
+    objects: ReadonlyArray<GraphQLObjectType>;
+    interfaces: ReadonlyArray<GraphQLInterfaceType>;
+  };
+  isSubType(
+    abstractType: GraphQLAbstractType,
+    maybeSubType: GraphQLObjectType | GraphQLInterfaceType,
+  ): boolean;
+  getDirectives(): ReadonlyArray<GraphQLDirective>;
+  getDirective(name: string): Maybe<GraphQLDirective>;
+  toConfig(): GraphQLSchemaNormalizedConfig;
+}
+declare type TypeMap = ObjMap$1<GraphQLNamedType>;
+interface GraphQLSchemaValidationOptions {
+  /**
+   * When building a schema from a GraphQL service's introspection result, it
+   * might be safe to assume the schema is valid. Set to true to assume the
+   * produced schema is valid.
+   *
+   * Default: false
+   */
+  assumeValid?: boolean;
+}
+interface GraphQLSchemaConfig extends GraphQLSchemaValidationOptions {
+  description?: Maybe<string>;
+  query?: Maybe<GraphQLObjectType>;
+  mutation?: Maybe<GraphQLObjectType>;
+  subscription?: Maybe<GraphQLObjectType>;
+  types?: Maybe<ReadonlyArray<GraphQLNamedType>>;
+  directives?: Maybe<ReadonlyArray<GraphQLDirective>>;
+  extensions?: Maybe<Readonly<GraphQLSchemaExtensions>>;
+  astNode?: Maybe<SchemaDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<SchemaExtensionNode>>;
+}
+/**
+ * @internal
+ */
+interface GraphQLSchemaNormalizedConfig extends GraphQLSchemaConfig {
+  description: Maybe<string>;
+  types: ReadonlyArray<GraphQLNamedType>;
+  directives: ReadonlyArray<GraphQLDirective>;
+  extensions: Readonly<GraphQLSchemaExtensions>;
+  extensionASTNodes: ReadonlyArray<SchemaExtensionNode>;
+  assumeValid: boolean;
+}
+
+/**
+ * These are all of the possible kinds of types.
+ */
+declare type GraphQLType =
+  | GraphQLScalarType
+  | GraphQLObjectType
+  | GraphQLInterfaceType
+  | GraphQLUnionType
+  | GraphQLEnumType
+  | GraphQLInputObjectType
+  | GraphQLList<GraphQLType>
+  | GraphQLNonNull<
+      | GraphQLScalarType
+      | GraphQLObjectType
+      | GraphQLInterfaceType
+      | GraphQLUnionType
+      | GraphQLEnumType
+      | GraphQLInputObjectType
+      | GraphQLList<GraphQLType>
+    >;
+/**
+ * These types may be used as input types for arguments and directives.
+ */
+declare type GraphQLInputType =
+  | GraphQLScalarType
+  | GraphQLEnumType
+  | GraphQLInputObjectType
+  | GraphQLList<GraphQLInputType>
+  | GraphQLNonNull<
+      | GraphQLScalarType
+      | GraphQLEnumType
+      | GraphQLInputObjectType
+      | GraphQLList<GraphQLInputType>
+    >;
+/**
+ * These types may be used as output types as the result of fields.
+ */
+declare type GraphQLOutputType =
+  | GraphQLScalarType
+  | GraphQLObjectType
+  | GraphQLInterfaceType
+  | GraphQLUnionType
+  | GraphQLEnumType
+  | GraphQLList<GraphQLOutputType>
+  | GraphQLNonNull<
+      | GraphQLScalarType
+      | GraphQLObjectType
+      | GraphQLInterfaceType
+      | GraphQLUnionType
+      | GraphQLEnumType
+      | GraphQLList<GraphQLOutputType>
+    >;
+/**
+ * These types may describe the parent context of a selection set.
+ */
+declare type GraphQLAbstractType =
+  | GraphQLInterfaceType
+  | GraphQLUnionType;
+/**
+ * List Type Wrapper
+ *
+ * A list is a wrapping type which points to another type.
+ * Lists are often created within the context of defining the fields of
+ * an object type.
+ *
+ * Example:
+ *
+ * ```ts
+ * const PersonType = new GraphQLObjectType({
+ *   name: 'Person',
+ *   fields: () => ({
+ *     parents: { type: new GraphQLList(PersonType) },
+ *     children: { type: new GraphQLList(PersonType) },
+ *   })
+ * })
+ * ```
+ */
+declare class GraphQLList<T extends GraphQLType> {
+  readonly ofType: T;
+  constructor(ofType: T);
+  get [Symbol.toStringTag](): string;
+  toString(): string;
+  toJSON(): string;
+}
+/**
+ * Non-Null Type Wrapper
+ *
+ * A non-null is a wrapping type which points to another type.
+ * Non-null types enforce that their values are never null and can ensure
+ * an error is raised if this ever occurs during a request. It is useful for
+ * fields which you can make a strong guarantee on non-nullability, for example
+ * usually the id field of a database row will never be null.
+ *
+ * Example:
+ *
+ * ```ts
+ * const RowType = new GraphQLObjectType({
+ *   name: 'Row',
+ *   fields: () => ({
+ *     id: { type: new GraphQLNonNull(GraphQLString) },
+ *   })
+ * })
+ * ```
+ * Note: the enforcement of non-nullability occurs within the executor.
+ */
+declare class GraphQLNonNull<T extends GraphQLNullableType> {
+  readonly ofType: T;
+  constructor(ofType: T);
+  get [Symbol.toStringTag](): string;
+  toString(): string;
+  toJSON(): string;
+}
+/**
+ * These types can all accept null as a value.
+ */
+declare type GraphQLNullableType =
+  | GraphQLScalarType
+  | GraphQLObjectType
+  | GraphQLInterfaceType
+  | GraphQLUnionType
+  | GraphQLEnumType
+  | GraphQLInputObjectType
+  | GraphQLList<GraphQLType>;
+/**
+ * These named types do not include modifiers like List or NonNull.
+ */
+declare type GraphQLNamedType =
+  | GraphQLNamedInputType
+  | GraphQLNamedOutputType;
+declare type GraphQLNamedInputType =
+  | GraphQLScalarType
+  | GraphQLEnumType
+  | GraphQLInputObjectType;
+declare type GraphQLNamedOutputType =
+  | GraphQLScalarType
+  | GraphQLObjectType
+  | GraphQLInterfaceType
+  | GraphQLUnionType
+  | GraphQLEnumType;
+/**
+ * Used while defining GraphQL types to allow for circular references in
+ * otherwise immutable type definitions.
+ */
+declare type ThunkReadonlyArray<T> =
+  | (() => ReadonlyArray<T>)
+  | ReadonlyArray<T>;
+declare type ThunkObjMap<T> = (() => ObjMap$1<T>) | ObjMap$1<T>;
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLScalarTypeExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Scalar Type Definition
+ *
+ * The leaf values of any request and input values to arguments are
+ * Scalars (or Enums) and are defined with a name and a series of functions
+ * used to parse input from ast or variables and to ensure validity.
+ *
+ * If a type's serialize function returns `null` or does not return a value
+ * (i.e. it returns `undefined`) then an error will be raised and a `null`
+ * value will be returned in the response. It is always better to validate
+ *
+ * Example:
+ *
+ * ```ts
+ * const OddType = new GraphQLScalarType({
+ *   name: 'Odd',
+ *   serialize(value) {
+ *     if (!Number.isFinite(value)) {
+ *       throw new Error(
+ *         `Scalar "Odd" cannot represent "${value}" since it is not a finite number.`,
+ *       );
+ *     }
+ *
+ *     if (value % 2 === 0) {
+ *       throw new Error(`Scalar "Odd" cannot represent "${value}" since it is even.`);
+ *     }
+ *     return value;
+ *   }
+ * });
+ * ```
+ */
+declare class GraphQLScalarType<
+  TInternal = unknown,
+  TExternal = TInternal,
+> {
+  name: string;
+  description: Maybe<string>;
+  specifiedByURL: Maybe<string>;
+  serialize: GraphQLScalarSerializer<TExternal>;
+  parseValue: GraphQLScalarValueParser<TInternal>;
+  parseLiteral: GraphQLScalarLiteralParser<TInternal>;
+  extensions: Readonly<GraphQLScalarTypeExtensions>;
+  astNode: Maybe<ScalarTypeDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>;
+  constructor(config: Readonly<GraphQLScalarTypeConfig<TInternal, TExternal>>);
+  get [Symbol.toStringTag](): string;
+  toConfig(): GraphQLScalarTypeNormalizedConfig<TInternal, TExternal>;
+  toString(): string;
+  toJSON(): string;
+}
+declare type GraphQLScalarSerializer<TExternal> = (
+  outputValue: unknown,
+) => TExternal;
+declare type GraphQLScalarValueParser<TInternal> = (
+  inputValue: unknown,
+) => TInternal;
+declare type GraphQLScalarLiteralParser<TInternal> = (
+  valueNode: ValueNode,
+  variables?: Maybe<ObjMap$1<unknown>>,
+) => TInternal;
+interface GraphQLScalarTypeConfig<TInternal, TExternal> {
+  name: string;
+  description?: Maybe<string>;
+  specifiedByURL?: Maybe<string>;
+  /** Serializes an internal value to include in a response. */
+  serialize?: GraphQLScalarSerializer<TExternal>;
+  /** Parses an externally provided value to use as an input. */
+  parseValue?: GraphQLScalarValueParser<TInternal>;
+  /** Parses an externally provided literal value to use as an input. */
+  parseLiteral?: GraphQLScalarLiteralParser<TInternal>;
+  extensions?: Maybe<Readonly<GraphQLScalarTypeExtensions>>;
+  astNode?: Maybe<ScalarTypeDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<ScalarTypeExtensionNode>>;
+}
+interface GraphQLScalarTypeNormalizedConfig<TInternal, TExternal>
+  extends GraphQLScalarTypeConfig<TInternal, TExternal> {
+  serialize: GraphQLScalarSerializer<TExternal>;
+  parseValue: GraphQLScalarValueParser<TInternal>;
+  parseLiteral: GraphQLScalarLiteralParser<TInternal>;
+  extensions: Readonly<GraphQLScalarTypeExtensions>;
+  extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ *
+ * We've provided these template arguments because this is an open type and
+ * you may find them useful.
+ */
+interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
+  [attributeName: string]: unknown;
+}
+/**
+ * Object Type Definition
+ *
+ * Almost all of the GraphQL types you define will be object types. Object types
+ * have a name, but most importantly describe their fields.
+ *
+ * Example:
+ *
+ * ```ts
+ * const AddressType = new GraphQLObjectType({
+ *   name: 'Address',
+ *   fields: {
+ *     street: { type: GraphQLString },
+ *     number: { type: GraphQLInt },
+ *     formatted: {
+ *       type: GraphQLString,
+ *       resolve(obj) {
+ *         return obj.number + ' ' + obj.street
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * When two types need to refer to each other, or a type needs to refer to
+ * itself in a field, you can use a function expression (aka a closure or a
+ * thunk) to supply the fields lazily.
+ *
+ * Example:
+ *
+ * ```ts
+ * const PersonType = new GraphQLObjectType({
+ *   name: 'Person',
+ *   fields: () => ({
+ *     name: { type: GraphQLString },
+ *     bestFriend: { type: PersonType },
+ *   })
+ * });
+ * ```
+ */
+declare class GraphQLObjectType<TSource = any, TContext = any> {
+  name: string;
+  description: Maybe<string>;
+  isTypeOf: Maybe<GraphQLIsTypeOfFn<TSource, TContext>>;
+  extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
+  astNode: Maybe<ObjectTypeDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
+  private _fields;
+  private _interfaces;
+  constructor(config: Readonly<GraphQLObjectTypeConfig<TSource, TContext>>);
+  get [Symbol.toStringTag](): string;
+  getFields(): GraphQLFieldMap<TSource, TContext>;
+  getInterfaces(): ReadonlyArray<GraphQLInterfaceType>;
+  toConfig(): GraphQLObjectTypeNormalizedConfig<TSource, TContext>;
+  toString(): string;
+  toJSON(): string;
+}
+interface GraphQLObjectTypeConfig<TSource, TContext> {
+  name: string;
+  description?: Maybe<string>;
+  interfaces?: ThunkReadonlyArray<GraphQLInterfaceType>;
+  fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;
+  isTypeOf?: Maybe<GraphQLIsTypeOfFn<TSource, TContext>>;
+  extensions?: Maybe<Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>>;
+  astNode?: Maybe<ObjectTypeDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<ObjectTypeExtensionNode>>;
+}
+interface GraphQLObjectTypeNormalizedConfig<TSource, TContext>
+  extends GraphQLObjectTypeConfig<any, any> {
+  interfaces: ReadonlyArray<GraphQLInterfaceType>;
+  fields: GraphQLFieldConfigMap<any, any>;
+  extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
+  extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
+}
+declare type GraphQLTypeResolver<TSource, TContext> = (
+  value: TSource,
+  context: TContext,
+  info: GraphQLResolveInfo,
+  abstractType: GraphQLAbstractType,
+) => PromiseOrValue<string | undefined>;
+declare type GraphQLIsTypeOfFn<TSource, TContext> = (
+  source: TSource,
+  context: TContext,
+  info: GraphQLResolveInfo,
+) => PromiseOrValue<boolean>;
+declare type GraphQLFieldResolver<
+  TSource,
+  TContext,
+  TArgs = any,
+  TResult = unknown,
+> = (
+  source: TSource,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo,
+) => TResult;
+interface GraphQLResolveInfo {
+  readonly fieldName: string;
+  readonly fieldNodes: ReadonlyArray<FieldNode>;
+  readonly returnType: GraphQLOutputType;
+  readonly parentType: GraphQLObjectType;
+  readonly path: Path;
+  readonly schema: GraphQLSchema;
+  readonly fragments: ObjMap$1<FragmentDefinitionNode>;
+  readonly rootValue: unknown;
+  readonly operation: OperationDefinitionNode;
+  readonly variableValues: {
+    [variable: string]: unknown;
+  };
+}
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ *
+ * We've provided these template arguments because this is an open type and
+ * you may find them useful.
+ */
+interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs = any> {
+  [attributeName: string]: unknown;
+}
+interface GraphQLFieldConfig<TSource, TContext, TArgs = any> {
+  description?: Maybe<string>;
+  type: GraphQLOutputType;
+  args?: GraphQLFieldConfigArgumentMap;
+  resolve?: GraphQLFieldResolver<TSource, TContext, TArgs>;
+  subscribe?: GraphQLFieldResolver<TSource, TContext, TArgs>;
+  deprecationReason?: Maybe<string>;
+  extensions?: Maybe<
+    Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>
+  >;
+  astNode?: Maybe<FieldDefinitionNode>;
+}
+declare type GraphQLFieldConfigArgumentMap =
+  ObjMap$1<GraphQLArgumentConfig>;
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLArgumentExtensions {
+  [attributeName: string]: unknown;
+}
+interface GraphQLArgumentConfig {
+  description?: Maybe<string>;
+  type: GraphQLInputType;
+  defaultValue?: unknown;
+  deprecationReason?: Maybe<string>;
+  extensions?: Maybe<Readonly<GraphQLArgumentExtensions>>;
+  astNode?: Maybe<InputValueDefinitionNode>;
+}
+declare type GraphQLFieldConfigMap<TSource, TContext> = ObjMap$1<
+  GraphQLFieldConfig<TSource, TContext>
+>;
+interface GraphQLField<TSource, TContext, TArgs = any> {
+  name: string;
+  description: Maybe<string>;
+  type: GraphQLOutputType;
+  args: ReadonlyArray<GraphQLArgument>;
+  resolve?: GraphQLFieldResolver<TSource, TContext, TArgs>;
+  subscribe?: GraphQLFieldResolver<TSource, TContext, TArgs>;
+  deprecationReason: Maybe<string>;
+  extensions: Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>;
+  astNode: Maybe<FieldDefinitionNode>;
+}
+interface GraphQLArgument {
+  name: string;
+  description: Maybe<string>;
+  type: GraphQLInputType;
+  defaultValue: unknown;
+  deprecationReason: Maybe<string>;
+  extensions: Readonly<GraphQLArgumentExtensions>;
+  astNode: Maybe<InputValueDefinitionNode>;
+}
+declare type GraphQLFieldMap<TSource, TContext> = ObjMap$1<
+  GraphQLField<TSource, TContext>
+>;
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLInterfaceTypeExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Interface Type Definition
+ *
+ * When a field can return one of a heterogeneous set of types, a Interface type
+ * is used to describe what types are possible, what fields are in common across
+ * all types, as well as a function to determine which type is actually used
+ * when the field is resolved.
+ *
+ * Example:
+ *
+ * ```ts
+ * const EntityType = new GraphQLInterfaceType({
+ *   name: 'Entity',
+ *   fields: {
+ *     name: { type: GraphQLString }
+ *   }
+ * });
+ * ```
+ */
+declare class GraphQLInterfaceType {
+  name: string;
+  description: Maybe<string>;
+  resolveType: Maybe<GraphQLTypeResolver<any, any>>;
+  extensions: Readonly<GraphQLInterfaceTypeExtensions>;
+  astNode: Maybe<InterfaceTypeDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<InterfaceTypeExtensionNode>;
+  private _fields;
+  private _interfaces;
+  constructor(config: Readonly<GraphQLInterfaceTypeConfig<any, any>>);
+  get [Symbol.toStringTag](): string;
+  getFields(): GraphQLFieldMap<any, any>;
+  getInterfaces(): ReadonlyArray<GraphQLInterfaceType>;
+  toConfig(): GraphQLInterfaceTypeNormalizedConfig;
+  toString(): string;
+  toJSON(): string;
+}
+interface GraphQLInterfaceTypeConfig<TSource, TContext> {
+  name: string;
+  description?: Maybe<string>;
+  interfaces?: ThunkReadonlyArray<GraphQLInterfaceType>;
+  fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;
+  /**
+   * Optionally provide a custom type resolver function. If one is not provided,
+   * the default implementation will call `isTypeOf` on each implementing
+   * Object type.
+   */
+  resolveType?: Maybe<GraphQLTypeResolver<TSource, TContext>>;
+  extensions?: Maybe<Readonly<GraphQLInterfaceTypeExtensions>>;
+  astNode?: Maybe<InterfaceTypeDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<InterfaceTypeExtensionNode>>;
+}
+interface GraphQLInterfaceTypeNormalizedConfig
+  extends GraphQLInterfaceTypeConfig<any, any> {
+  interfaces: ReadonlyArray<GraphQLInterfaceType>;
+  fields: GraphQLFieldConfigMap<any, any>;
+  extensions: Readonly<GraphQLInterfaceTypeExtensions>;
+  extensionASTNodes: ReadonlyArray<InterfaceTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLUnionTypeExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Union Type Definition
+ *
+ * When a field can return one of a heterogeneous set of types, a Union type
+ * is used to describe what types are possible as well as providing a function
+ * to determine which type is actually used when the field is resolved.
+ *
+ * Example:
+ *
+ * ```ts
+ * const PetType = new GraphQLUnionType({
+ *   name: 'Pet',
+ *   types: [ DogType, CatType ],
+ *   resolveType(value) {
+ *     if (value instanceof Dog) {
+ *       return DogType;
+ *     }
+ *     if (value instanceof Cat) {
+ *       return CatType;
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare class GraphQLUnionType {
+  name: string;
+  description: Maybe<string>;
+  resolveType: Maybe<GraphQLTypeResolver<any, any>>;
+  extensions: Readonly<GraphQLUnionTypeExtensions>;
+  astNode: Maybe<UnionTypeDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
+  private _types;
+  constructor(config: Readonly<GraphQLUnionTypeConfig<any, any>>);
+  get [Symbol.toStringTag](): string;
+  getTypes(): ReadonlyArray<GraphQLObjectType>;
+  toConfig(): GraphQLUnionTypeNormalizedConfig;
+  toString(): string;
+  toJSON(): string;
+}
+interface GraphQLUnionTypeConfig<TSource, TContext> {
+  name: string;
+  description?: Maybe<string>;
+  types: ThunkReadonlyArray<GraphQLObjectType>;
+  /**
+   * Optionally provide a custom type resolver function. If one is not provided,
+   * the default implementation will call `isTypeOf` on each implementing
+   * Object type.
+   */
+  resolveType?: Maybe<GraphQLTypeResolver<TSource, TContext>>;
+  extensions?: Maybe<Readonly<GraphQLUnionTypeExtensions>>;
+  astNode?: Maybe<UnionTypeDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<UnionTypeExtensionNode>>;
+}
+interface GraphQLUnionTypeNormalizedConfig
+  extends GraphQLUnionTypeConfig<any, any> {
+  types: ReadonlyArray<GraphQLObjectType>;
+  extensions: Readonly<GraphQLUnionTypeExtensions>;
+  extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLEnumTypeExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Enum Type Definition
+ *
+ * Some leaf values of requests and input values are Enums. GraphQL serializes
+ * Enum values as strings, however internally Enums can be represented by any
+ * kind of type, often integers.
+ *
+ * Example:
+ *
+ * ```ts
+ * const RGBType = new GraphQLEnumType({
+ *   name: 'RGB',
+ *   values: {
+ *     RED: { value: 0 },
+ *     GREEN: { value: 1 },
+ *     BLUE: { value: 2 }
+ *   }
+ * });
+ * ```
+ *
+ * Note: If a value is not provided in a definition, the name of the enum value
+ * will be used as its internal value.
+ */
+declare class GraphQLEnumType {
+  name: string;
+  description: Maybe<string>;
+  extensions: Readonly<GraphQLEnumTypeExtensions>;
+  astNode: Maybe<EnumTypeDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>;
+  private _values;
+  private _valueLookup;
+  private _nameLookup;
+  constructor(config: Readonly<GraphQLEnumTypeConfig>);
+  get [Symbol.toStringTag](): string;
+  getValues(): ReadonlyArray<GraphQLEnumValue>;
+  getValue(name: string): Maybe<GraphQLEnumValue>;
+  serialize(outputValue: unknown): Maybe<string>;
+  parseValue(inputValue: unknown): Maybe<any>;
+  parseLiteral(
+    valueNode: ValueNode,
+    _variables: Maybe<ObjMap$1<unknown>>,
+  ): Maybe<any>;
+  toConfig(): GraphQLEnumTypeNormalizedConfig;
+  toString(): string;
+  toJSON(): string;
+}
+interface GraphQLEnumTypeConfig {
+  name: string;
+  description?: Maybe<string>;
+  values: GraphQLEnumValueConfigMap;
+  extensions?: Maybe<Readonly<GraphQLEnumTypeExtensions>>;
+  astNode?: Maybe<EnumTypeDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<EnumTypeExtensionNode>>;
+}
+interface GraphQLEnumTypeNormalizedConfig extends GraphQLEnumTypeConfig {
+  extensions: Readonly<GraphQLEnumTypeExtensions>;
+  extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>;
+}
+declare type GraphQLEnumValueConfigMap = ObjMap$1<GraphQLEnumValueConfig>;
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLEnumValueExtensions {
+  [attributeName: string]: unknown;
+}
+interface GraphQLEnumValueConfig {
+  description?: Maybe<string>;
+  value?: any;
+  deprecationReason?: Maybe<string>;
+  extensions?: Maybe<Readonly<GraphQLEnumValueExtensions>>;
+  astNode?: Maybe<EnumValueDefinitionNode>;
+}
+interface GraphQLEnumValue {
+  name: string;
+  description: Maybe<string>;
+  value: any;
+  deprecationReason: Maybe<string>;
+  extensions: Readonly<GraphQLEnumValueExtensions>;
+  astNode: Maybe<EnumValueDefinitionNode>;
+}
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLInputObjectTypeExtensions {
+  [attributeName: string]: unknown;
+}
+/**
+ * Input Object Type Definition
+ *
+ * An input object defines a structured collection of fields which may be
+ * supplied to a field argument.
+ *
+ * Using `NonNull` will ensure that a value must be provided by the query
+ *
+ * Example:
+ *
+ * ```ts
+ * const GeoPoint = new GraphQLInputObjectType({
+ *   name: 'GeoPoint',
+ *   fields: {
+ *     lat: { type: new GraphQLNonNull(GraphQLFloat) },
+ *     lon: { type: new GraphQLNonNull(GraphQLFloat) },
+ *     alt: { type: GraphQLFloat, defaultValue: 0 },
+ *   }
+ * });
+ * ```
+ */
+declare class GraphQLInputObjectType {
+  name: string;
+  description: Maybe<string>;
+  extensions: Readonly<GraphQLInputObjectTypeExtensions>;
+  astNode: Maybe<InputObjectTypeDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>;
+  private _fields;
+  constructor(config: Readonly<GraphQLInputObjectTypeConfig>);
+  get [Symbol.toStringTag](): string;
+  getFields(): GraphQLInputFieldMap;
+  toConfig(): GraphQLInputObjectTypeNormalizedConfig;
+  toString(): string;
+  toJSON(): string;
+}
+interface GraphQLInputObjectTypeConfig {
+  name: string;
+  description?: Maybe<string>;
+  fields: ThunkObjMap<GraphQLInputFieldConfig>;
+  extensions?: Maybe<Readonly<GraphQLInputObjectTypeExtensions>>;
+  astNode?: Maybe<InputObjectTypeDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<InputObjectTypeExtensionNode>>;
+}
+interface GraphQLInputObjectTypeNormalizedConfig
+  extends GraphQLInputObjectTypeConfig {
+  fields: GraphQLInputFieldConfigMap;
+  extensions: Readonly<GraphQLInputObjectTypeExtensions>;
+  extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>;
+}
+/**
+ * Custom extensions
+ *
+ * @remarks
+ * Use a unique identifier name for your extension, for example the name of
+ * your library or project. Do not use a shortened identifier as this increases
+ * the risk of conflicts. We recommend you add at most one extension field,
+ * an object which can contain all the values you need.
+ */
+interface GraphQLInputFieldExtensions {
+  [attributeName: string]: unknown;
+}
+interface GraphQLInputFieldConfig {
+  description?: Maybe<string>;
+  type: GraphQLInputType;
+  defaultValue?: unknown;
+  deprecationReason?: Maybe<string>;
+  extensions?: Maybe<Readonly<GraphQLInputFieldExtensions>>;
+  astNode?: Maybe<InputValueDefinitionNode>;
+}
+declare type GraphQLInputFieldConfigMap =
+  ObjMap$1<GraphQLInputFieldConfig>;
+interface GraphQLInputField {
+  name: string;
+  description: Maybe<string>;
+  type: GraphQLInputType;
+  defaultValue: unknown;
+  deprecationReason: Maybe<string>;
+  extensions: Readonly<GraphQLInputFieldExtensions>;
+  astNode: Maybe<InputValueDefinitionNode>;
+}
+declare type GraphQLInputFieldMap = ObjMap$1<GraphQLInputField>;
+
+interface FormattedExecutionResult<
+  TData = ObjMap$1<unknown>,
+  TExtensions = ObjMap$1<unknown>,
+> {
+  errors?: ReadonlyArray<GraphQLFormattedError>;
+  data?: TData | null;
+  extensions?: TExtensions;
+}
+
+interface KeyValueCache<V = string> {
+    get(key: string): Promise<V | undefined>;
+    set(key: string, value: V, options?: KeyValueCacheSetOptions): Promise<void>;
+    delete(key: string): Promise<boolean | void>;
+}
+interface KeyValueCacheSetOptions {
+    ttl?: number | null;
+}
+
+type BaseContext = {};
+
+declare class HeaderMap extends Map<string, string> {
+    private __identity;
+    set(key: string, value: string): this;
+    get(key: string): string | undefined;
+    delete(key: string): boolean;
+    has(key: string): boolean;
+}
+
+interface HTTPGraphQLRequest {
+    method: string;
+    headers: HeaderMap;
+    search: string;
+    body: unknown;
+}
+interface HTTPGraphQLHead {
+    status?: number;
+    headers: HeaderMap;
+}
+
+type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
+
+interface ObjMap<T> {
+    [key: string]: T;
+}
+interface GraphQLExperimentalFormattedInitialIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TData, TExtensions> {
+    hasNext: boolean;
+    incremental?: ReadonlyArray<GraphQLExperimentalFormattedIncrementalResult<TData, TExtensions>>;
+    extensions?: TExtensions;
+}
+interface GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+    hasNext: boolean;
+    incremental?: ReadonlyArray<GraphQLExperimentalFormattedIncrementalResult<TData, TExtensions>>;
+    extensions?: TExtensions;
+}
+type GraphQLExperimentalFormattedIncrementalResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> = GraphQLExperimentalFormattedIncrementalDeferResult<TData, TExtensions> | GraphQLExperimentalFormattedIncrementalStreamResult<TData, TExtensions>;
+interface GraphQLExperimentalFormattedIncrementalDeferResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TData, TExtensions> {
+    path?: ReadonlyArray<string | number>;
+    label?: string;
+}
+interface GraphQLExperimentalFormattedIncrementalStreamResult<TData = Array<unknown>, TExtensions = ObjMap<unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    items?: TData | null;
+    path?: ReadonlyArray<string | number>;
+    label?: string;
+    extensions?: TExtensions;
+}
+
+interface GraphQLRequest<TVariables extends VariableValues = VariableValues> {
+    query?: string;
+    operationName?: string;
+    variables?: TVariables;
+    extensions?: Record<string, any>;
+    http?: HTTPGraphQLRequest;
+}
+type VariableValues = {
+    [name: string]: any;
+};
+type GraphQLResponseBody<TData = Record<string, unknown>> = {
+    kind: 'single';
+    singleResult: FormattedExecutionResult<TData>;
+} | {
+    kind: 'incremental';
+    initialResult: GraphQLExperimentalFormattedInitialIncrementalExecutionResult;
+    subsequentResults: AsyncIterable<GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult>;
+};
+type GraphQLInProgressResponse<TData = Record<string, unknown>> = {
+    http: HTTPGraphQLHead;
+    body?: GraphQLResponseBody<TData>;
+};
+type GraphQLResponse<TData = Record<string, unknown>> = WithRequired<GraphQLInProgressResponse<TData>, 'body'>;
+
+// DO NOT EDIT! This is a generated file. Edit the JSDoc in src/*.js instead and run 'npm run types'.
+
+
+/** Wire format reader using `Uint8Array` if available, otherwise `Array`. */
+declare class Reader {
+
+    /**
+     * Constructs a new reader instance using the specified buffer.
+     * @param buffer Buffer to read from
+     */
+    constructor(buffer: Uint8Array);
+
+    /** Read buffer. */
+    public buf: Uint8Array;
+
+    /** Read buffer position. */
+    public pos: number;
+
+    /** Read buffer length. */
+    public len: number;
+
+    /**
+     * Creates a new reader using the specified buffer.
+     * @param buffer Buffer to read from
+     * @returns A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
+     * @throws {Error} If `buffer` is not a valid buffer
+     */
+    public static create(buffer: (Uint8Array|Buffer)): (Reader|BufferReader);
+
+    /**
+     * Reads a varint as an unsigned 32 bit value.
+     * @returns Value read
+     */
+    public uint32(): number;
+
+    /**
+     * Reads a varint as a signed 32 bit value.
+     * @returns Value read
+     */
+    public int32(): number;
+
+    /**
+     * Reads a zig-zag encoded varint as a signed 32 bit value.
+     * @returns Value read
+     */
+    public sint32(): number;
+
+    /**
+     * Reads a varint as a boolean.
+     * @returns Value read
+     */
+    public bool(): boolean;
+
+    /**
+     * Reads fixed 32 bits as an unsigned 32 bit integer.
+     * @returns Value read
+     */
+    public fixed32(): number;
+
+    /**
+     * Reads fixed 32 bits as a signed 32 bit integer.
+     * @returns Value read
+     */
+    public sfixed32(): number;
+
+    /**
+     * Reads a float (32 bit) as a number.
+     * @returns Value read
+     */
+    public float(): number;
+
+    /**
+     * Reads a double (64 bit float) as a number.
+     * @returns Value read
+     */
+    public double(): number;
+
+    /**
+     * Reads a sequence of bytes preceeded by its length as a varint.
+     * @returns Value read
+     */
+    public bytes(): Uint8Array;
+
+    /**
+     * Reads a string preceeded by its byte length as a varint.
+     * @returns Value read
+     */
+    public string(): string;
+
+    /**
+     * Skips the specified number of bytes if specified, otherwise skips a varint.
+     * @param [length] Length if known, otherwise a varint is assumed
+     * @returns `this`
+     */
+    public skip(length?: number): Reader;
+
+    /**
+     * Skips the next element of the specified wire type.
+     * @param wireType Wire type received
+     * @returns `this`
+     */
+    public skipType(wireType: number): Reader;
+}
+
+/** Wire format reader using node buffers. */
+declare class BufferReader extends Reader {
+
+    /**
+     * Constructs a new buffer reader instance.
+     * @param buffer Buffer to read from
+     */
+    constructor(buffer: Buffer);
+
+    /**
+     * Reads a sequence of bytes preceeded by its length as a varint.
+     * @returns Value read
+     */
+    public bytes(): Buffer;
+}
+
+/** Conversion options as used by {@link Type#toObject} and {@link Message.toObject}. */
+interface IConversionOptions {
+
+    /**
+     * Long conversion type.
+     * Valid values are `String` and `Number` (the global types).
+     * Defaults to copy the present value, which is a possibly unsafe number without and a {@link Long} with a long library.
+     */
+    longs?: Function;
+
+    /**
+     * Enum value conversion type.
+     * Only valid value is `String` (the global type).
+     * Defaults to copy the present value, which is the numeric id.
+     */
+    enums?: Function;
+
+    /**
+     * Bytes value conversion type.
+     * Valid values are `Array` and (a base64 encoded) `String` (the global types).
+     * Defaults to copy the present value, which usually is a Buffer under node and an Uint8Array in the browser.
+     */
+    bytes?: Function;
+
+    /** Also sets default values on the resulting object */
+    defaults?: boolean;
+
+    /** Sets empty arrays for missing repeated fields even if `defaults=false` */
+    arrays?: boolean;
+
+    /** Sets empty objects for missing map fields even if `defaults=false` */
+    objects?: boolean;
+
+    /** Includes virtual oneof properties set to the present field's name, if any */
+    oneofs?: boolean;
+
+    /** Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings */
+    json?: boolean;
+}
+
+/**
+ * Any compatible Buffer instance.
+ * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
+ */
+interface Buffer extends Uint8Array {
+}
+
+/** Wire format writer using `Uint8Array` if available, otherwise `Array`. */
+declare class Writer {
+
+    /** Constructs a new writer instance. */
+    constructor();
+
+    /** Current length. */
+    public len: number;
+
+    /** Operations head. */
+    public head: object;
+
+    /** Operations tail */
+    public tail: object;
+
+    /** Linked forked states. */
+    public states: (object|null);
+
+    /**
+     * Creates a new writer.
+     * @returns A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
+     */
+    public static create(): (BufferWriter|Writer);
+
+    /**
+     * Allocates a buffer of the specified size.
+     * @param size Buffer size
+     * @returns Buffer
+     */
+    public static alloc(size: number): Uint8Array;
+
+    /**
+     * Writes an unsigned 32 bit value as a varint.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public uint32(value: number): Writer;
+
+    /**
+     * Writes a signed 32 bit value as a varint.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public int32(value: number): Writer;
+
+    /**
+     * Writes a 32 bit value as a varint, zig-zag encoded.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public sint32(value: number): Writer;
+
+    /**
+     * Writes an unsigned 64 bit value as a varint.
+     * @param value Value to write
+     * @returns `this`
+     * @throws {TypeError} If `value` is a string and no long library is present.
+     */
+    public uint64(value: (number|string)): Writer;
+
+    /**
+     * Writes a signed 64 bit value as a varint.
+     * @param value Value to write
+     * @returns `this`
+     * @throws {TypeError} If `value` is a string and no long library is present.
+     */
+    public int64(value: (number|string)): Writer;
+
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded.
+     * @param value Value to write
+     * @returns `this`
+     * @throws {TypeError} If `value` is a string and no long library is present.
+     */
+    public sint64(value: (number|string)): Writer;
+
+    /**
+     * Writes a boolish value as a varint.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public bool(value: boolean): Writer;
+
+    /**
+     * Writes an unsigned 32 bit value as fixed 32 bits.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public fixed32(value: number): Writer;
+
+    /**
+     * Writes a signed 32 bit value as fixed 32 bits.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public sfixed32(value: number): Writer;
+
+    /**
+     * Writes an unsigned 64 bit value as fixed 64 bits.
+     * @param value Value to write
+     * @returns `this`
+     * @throws {TypeError} If `value` is a string and no long library is present.
+     */
+    public fixed64(value: (number|string)): Writer;
+
+    /**
+     * Writes a signed 64 bit value as fixed 64 bits.
+     * @param value Value to write
+     * @returns `this`
+     * @throws {TypeError} If `value` is a string and no long library is present.
+     */
+    public sfixed64(value: (number|string)): Writer;
+
+    /**
+     * Writes a float (32 bit).
+     * @param value Value to write
+     * @returns `this`
+     */
+    public float(value: number): Writer;
+
+    /**
+     * Writes a double (64 bit float).
+     * @param value Value to write
+     * @returns `this`
+     */
+    public double(value: number): Writer;
+
+    /**
+     * Writes a sequence of bytes.
+     * @param value Buffer or base64 encoded string to write
+     * @returns `this`
+     */
+    public bytes(value: (Uint8Array|string)): Writer;
+
+    /**
+     * Writes a string.
+     * @param value Value to write
+     * @returns `this`
+     */
+    public string(value: string): Writer;
+
+    /**
+     * Forks this writer's state by pushing it to a stack.
+     * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+     * @returns `this`
+     */
+    public fork(): Writer;
+
+    /**
+     * Resets this instance to the last state.
+     * @returns `this`
+     */
+    public reset(): Writer;
+
+    /**
+     * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+     * @returns `this`
+     */
+    public ldelim(): Writer;
+
+    /**
+     * Finishes the write operation.
+     * @returns Finished buffer
+     */
+    public finish(): Uint8Array;
+}
+
+/** Wire format writer using node buffers. */
+declare class BufferWriter extends Writer {
+
+    /** Constructs a new buffer writer instance. */
+    constructor();
+
+    /**
+     * Finishes the write operation.
+     * @returns Finished buffer
+     */
+    public finish(): Buffer;
+
+    /**
+     * Allocates a buffer of the specified size.
+     * @param size Buffer size
+     * @returns Buffer
+     */
+    public static alloc(size: number): Buffer;
+}
+
+interface NonFtv1ErrorPath {
+    subgraph: string;
+    path: GraphQLError['path'];
+}
+
+interface ApolloConfig {
+    key?: string;
+    keyHash?: string;
+    graphRef?: string;
+}
+
+/** Properties of a Trace. */
+interface ITrace {
+
+    /** Trace startTime */
+    startTime?: (google.protobuf.ITimestamp|null);
+
+    /** Trace endTime */
+    endTime?: (google.protobuf.ITimestamp|null);
+
+    /** Trace durationNs */
+    durationNs?: (number|null);
+
+    /** Trace root */
+    root?: (Trace.INode|null);
+
+    /** Trace isIncomplete */
+    isIncomplete?: (boolean|null);
+
+    /** Trace signature */
+    signature?: (string|null);
+
+    /** Trace unexecutedOperationBody */
+    unexecutedOperationBody?: (string|null);
+
+    /** Trace unexecutedOperationName */
+    unexecutedOperationName?: (string|null);
+
+    /** Trace details */
+    details?: (Trace.IDetails|null);
+
+    /** Trace clientName */
+    clientName?: (string|null);
+
+    /** Trace clientVersion */
+    clientVersion?: (string|null);
+
+    /** Trace http */
+    http?: (Trace.IHTTP|null);
+
+    /** Trace cachePolicy */
+    cachePolicy?: (Trace.ICachePolicy|null);
+
+    /** Trace queryPlan */
+    queryPlan?: (Trace.IQueryPlanNode|null);
+
+    /** Trace fullQueryCacheHit */
+    fullQueryCacheHit?: (boolean|null);
+
+    /** Trace persistedQueryHit */
+    persistedQueryHit?: (boolean|null);
+
+    /** Trace persistedQueryRegister */
+    persistedQueryRegister?: (boolean|null);
+
+    /** Trace registeredOperation */
+    registeredOperation?: (boolean|null);
+
+    /** Trace forbiddenOperation */
+    forbiddenOperation?: (boolean|null);
+
+    /** Trace fieldExecutionWeight */
+    fieldExecutionWeight?: (number|null);
+}
+
+/** Represents a Trace. */
+declare class Trace implements ITrace {
+
+    /**
+     * Constructs a new Trace.
+     * @param [properties] Properties to set
+     */
+    constructor(properties?: ITrace);
+
+    /** Trace startTime. */
+    public startTime?: (google.protobuf.ITimestamp|null);
+
+    /** Trace endTime. */
+    public endTime?: (google.protobuf.ITimestamp|null);
+
+    /** Trace durationNs. */
+    public durationNs: number;
+
+    /** Trace root. */
+    public root?: (Trace.INode|null);
+
+    /** Trace isIncomplete. */
+    public isIncomplete: boolean;
+
+    /** Trace signature. */
+    public signature: string;
+
+    /** Trace unexecutedOperationBody. */
+    public unexecutedOperationBody: string;
+
+    /** Trace unexecutedOperationName. */
+    public unexecutedOperationName: string;
+
+    /** Trace details. */
+    public details?: (Trace.IDetails|null);
+
+    /** Trace clientName. */
+    public clientName: string;
+
+    /** Trace clientVersion. */
+    public clientVersion: string;
+
+    /** Trace http. */
+    public http?: (Trace.IHTTP|null);
+
+    /** Trace cachePolicy. */
+    public cachePolicy?: (Trace.ICachePolicy|null);
+
+    /** Trace queryPlan. */
+    public queryPlan?: (Trace.IQueryPlanNode|null);
+
+    /** Trace fullQueryCacheHit. */
+    public fullQueryCacheHit: boolean;
+
+    /** Trace persistedQueryHit. */
+    public persistedQueryHit: boolean;
+
+    /** Trace persistedQueryRegister. */
+    public persistedQueryRegister: boolean;
+
+    /** Trace registeredOperation. */
+    public registeredOperation: boolean;
+
+    /** Trace forbiddenOperation. */
+    public forbiddenOperation: boolean;
+
+    /** Trace fieldExecutionWeight. */
+    public fieldExecutionWeight: number;
+
+    /**
+     * Creates a new Trace instance using the specified properties.
+     * @param [properties] Properties to set
+     * @returns Trace instance
+     */
+    public static create(properties?: ITrace): Trace;
+
+    /**
+     * Encodes the specified Trace message. Does not implicitly {@link Trace.verify|verify} messages.
+     * @param message Trace message or plain object to encode
+     * @param [writer] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(message: ITrace, writer?: Writer): Writer;
+
+    /**
+     * Encodes the specified Trace message, length delimited. Does not implicitly {@link Trace.verify|verify} messages.
+     * @param message Trace message or plain object to encode
+     * @param [writer] Writer to encode to
+     * @returns Writer
+     */
+    public static encodeDelimited(message: ITrace, writer?: Writer): Writer;
+
+    /**
+     * Decodes a Trace message from the specified reader or buffer.
+     * @param reader Reader or buffer to decode from
+     * @param [length] Message length if known beforehand
+     * @returns Trace
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(reader: (Reader|Uint8Array), length?: number): Trace;
+
+    /**
+     * Decodes a Trace message from the specified reader or buffer, length delimited.
+     * @param reader Reader or buffer to decode from
+     * @returns Trace
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decodeDelimited(reader: (Reader|Uint8Array)): Trace;
+
+    /**
+     * Verifies a Trace message.
+     * @param message Plain object to verify
+     * @returns `null` if valid, otherwise the reason why it is not
+     */
+    public static verify(message: { [k: string]: any }): (string|null);
+
+    /**
+     * Creates a plain object from a Trace message. Also converts values to other types if specified.
+     * @param message Trace
+     * @param [options] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(message: Trace, options?: IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Trace to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+declare namespace Trace {
+
+    /** Properties of a CachePolicy. */
+    interface ICachePolicy {
+
+        /** CachePolicy scope */
+        scope?: (Trace.CachePolicy.Scope|null);
+
+        /** CachePolicy maxAgeNs */
+        maxAgeNs?: (number|null);
+    }
+
+    /** Represents a CachePolicy. */
+    class CachePolicy implements ICachePolicy {
+
+        /**
+         * Constructs a new CachePolicy.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.ICachePolicy);
+
+        /** CachePolicy scope. */
+        public scope: Trace.CachePolicy.Scope;
+
+        /** CachePolicy maxAgeNs. */
+        public maxAgeNs: number;
+
+        /**
+         * Creates a new CachePolicy instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns CachePolicy instance
+         */
+        public static create(properties?: Trace.ICachePolicy): Trace.CachePolicy;
+
+        /**
+         * Encodes the specified CachePolicy message. Does not implicitly {@link Trace.CachePolicy.verify|verify} messages.
+         * @param message CachePolicy message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.ICachePolicy, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified CachePolicy message, length delimited. Does not implicitly {@link Trace.CachePolicy.verify|verify} messages.
+         * @param message CachePolicy message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.ICachePolicy, writer?: Writer): Writer;
+
+        /**
+         * Decodes a CachePolicy message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns CachePolicy
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.CachePolicy;
+
+        /**
+         * Decodes a CachePolicy message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns CachePolicy
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.CachePolicy;
+
+        /**
+         * Verifies a CachePolicy message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from a CachePolicy message. Also converts values to other types if specified.
+         * @param message CachePolicy
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.CachePolicy, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this CachePolicy to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    namespace CachePolicy {
+
+        /** Scope enum. */
+        declare enum Scope {
+            UNKNOWN = 0,
+            PUBLIC = 1,
+            PRIVATE = 2
+        }
+    }
+
+    /** Properties of a Details. */
+    interface IDetails {
+
+        /** Details variablesJson */
+        variablesJson?: ({ [k: string]: string }|null);
+
+        /** Details operationName */
+        operationName?: (string|null);
+    }
+
+    /** Represents a Details. */
+    class Details implements IDetails {
+
+        /**
+         * Constructs a new Details.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.IDetails);
+
+        /** Details variablesJson. */
+        public variablesJson: { [k: string]: string };
+
+        /** Details operationName. */
+        public operationName: string;
+
+        /**
+         * Creates a new Details instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns Details instance
+         */
+        public static create(properties?: Trace.IDetails): Trace.Details;
+
+        /**
+         * Encodes the specified Details message. Does not implicitly {@link Trace.Details.verify|verify} messages.
+         * @param message Details message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.IDetails, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified Details message, length delimited. Does not implicitly {@link Trace.Details.verify|verify} messages.
+         * @param message Details message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.IDetails, writer?: Writer): Writer;
+
+        /**
+         * Decodes a Details message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns Details
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.Details;
+
+        /**
+         * Decodes a Details message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns Details
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.Details;
+
+        /**
+         * Verifies a Details message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from a Details message. Also converts values to other types if specified.
+         * @param message Details
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.Details, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this Details to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    /** Properties of an Error. */
+    interface IError {
+
+        /** Error message */
+        message?: (string|null);
+
+        /** Error location */
+        location?: (Trace.ILocation[]|null);
+
+        /** Error timeNs */
+        timeNs?: (number|null);
+
+        /** Error json */
+        json?: (string|null);
+    }
+
+    /** Represents an Error. */
+    class Error implements IError {
+
+        /**
+         * Constructs a new Error.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.IError);
+
+        /** Error message. */
+        public message: string;
+
+        /** Error location. */
+        public location: Trace.ILocation[];
+
+        /** Error timeNs. */
+        public timeNs: number;
+
+        /** Error json. */
+        public json: string;
+
+        /**
+         * Creates a new Error instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns Error instance
+         */
+        public static create(properties?: Trace.IError): Trace.Error;
+
+        /**
+         * Encodes the specified Error message. Does not implicitly {@link Trace.Error.verify|verify} messages.
+         * @param message Error message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.IError, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified Error message, length delimited. Does not implicitly {@link Trace.Error.verify|verify} messages.
+         * @param message Error message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.IError, writer?: Writer): Writer;
+
+        /**
+         * Decodes an Error message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns Error
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.Error;
+
+        /**
+         * Decodes an Error message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns Error
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.Error;
+
+        /**
+         * Verifies an Error message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from an Error message. Also converts values to other types if specified.
+         * @param message Error
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.Error, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this Error to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    /** Properties of a HTTP. */
+    interface IHTTP {
+
+        /** HTTP method */
+        method?: (Trace.HTTP.Method|null);
+
+        /** HTTP requestHeaders */
+        requestHeaders?: ({ [k: string]: Trace.HTTP.IValues }|null);
+
+        /** HTTP responseHeaders */
+        responseHeaders?: ({ [k: string]: Trace.HTTP.IValues }|null);
+
+        /** HTTP statusCode */
+        statusCode?: (number|null);
+    }
+
+    /** Represents a HTTP. */
+    class HTTP implements IHTTP {
+
+        /**
+         * Constructs a new HTTP.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.IHTTP);
+
+        /** HTTP method. */
+        public method: Trace.HTTP.Method;
+
+        /** HTTP requestHeaders. */
+        public requestHeaders: { [k: string]: Trace.HTTP.IValues };
+
+        /** HTTP responseHeaders. */
+        public responseHeaders: { [k: string]: Trace.HTTP.IValues };
+
+        /** HTTP statusCode. */
+        public statusCode: number;
+
+        /**
+         * Creates a new HTTP instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns HTTP instance
+         */
+        public static create(properties?: Trace.IHTTP): Trace.HTTP;
+
+        /**
+         * Encodes the specified HTTP message. Does not implicitly {@link Trace.HTTP.verify|verify} messages.
+         * @param message HTTP message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.IHTTP, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified HTTP message, length delimited. Does not implicitly {@link Trace.HTTP.verify|verify} messages.
+         * @param message HTTP message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.IHTTP, writer?: Writer): Writer;
+
+        /**
+         * Decodes a HTTP message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns HTTP
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.HTTP;
+
+        /**
+         * Decodes a HTTP message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns HTTP
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.HTTP;
+
+        /**
+         * Verifies a HTTP message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from a HTTP message. Also converts values to other types if specified.
+         * @param message HTTP
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.HTTP, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this HTTP to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    namespace HTTP {
+
+        /** Properties of a Values. */
+        interface IValues {
+
+            /** Values value */
+            value?: (string[]|null);
+        }
+
+        /** Represents a Values. */
+        class Values implements IValues {
+
+            /**
+             * Constructs a new Values.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.HTTP.IValues);
+
+            /** Values value. */
+            public value: string[];
+
+            /**
+             * Creates a new Values instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns Values instance
+             */
+            public static create(properties?: Trace.HTTP.IValues): Trace.HTTP.Values;
+
+            /**
+             * Encodes the specified Values message. Does not implicitly {@link Trace.HTTP.Values.verify|verify} messages.
+             * @param message Values message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.HTTP.IValues, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified Values message, length delimited. Does not implicitly {@link Trace.HTTP.Values.verify|verify} messages.
+             * @param message Values message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.HTTP.IValues, writer?: Writer): Writer;
+
+            /**
+             * Decodes a Values message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns Values
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.HTTP.Values;
+
+            /**
+             * Decodes a Values message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns Values
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.HTTP.Values;
+
+            /**
+             * Verifies a Values message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a Values message. Also converts values to other types if specified.
+             * @param message Values
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.HTTP.Values, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this Values to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Method enum. */
+        declare enum Method {
+            UNKNOWN = 0,
+            OPTIONS = 1,
+            GET = 2,
+            HEAD = 3,
+            POST = 4,
+            PUT = 5,
+            DELETE = 6,
+            TRACE = 7,
+            CONNECT = 8,
+            PATCH = 9
+        }
+    }
+
+    /** Properties of a Location. */
+    interface ILocation {
+
+        /** Location line */
+        line?: (number|null);
+
+        /** Location column */
+        column?: (number|null);
+    }
+
+    /** Represents a Location. */
+    class Location implements ILocation {
+
+        /**
+         * Constructs a new Location.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.ILocation);
+
+        /** Location line. */
+        public line: number;
+
+        /** Location column. */
+        public column: number;
+
+        /**
+         * Creates a new Location instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns Location instance
+         */
+        public static create(properties?: Trace.ILocation): Trace.Location;
+
+        /**
+         * Encodes the specified Location message. Does not implicitly {@link Trace.Location.verify|verify} messages.
+         * @param message Location message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.ILocation, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified Location message, length delimited. Does not implicitly {@link Trace.Location.verify|verify} messages.
+         * @param message Location message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.ILocation, writer?: Writer): Writer;
+
+        /**
+         * Decodes a Location message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns Location
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.Location;
+
+        /**
+         * Decodes a Location message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns Location
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.Location;
+
+        /**
+         * Verifies a Location message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from a Location message. Also converts values to other types if specified.
+         * @param message Location
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.Location, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this Location to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    /** Properties of a Node. */
+    interface INode {
+
+        /** Node responseName */
+        responseName?: (string|null);
+
+        /** Node index */
+        index?: (number|null);
+
+        /** Node originalFieldName */
+        originalFieldName?: (string|null);
+
+        /** Node type */
+        type?: (string|null);
+
+        /** Node parentType */
+        parentType?: (string|null);
+
+        /** Node cachePolicy */
+        cachePolicy?: (Trace.ICachePolicy|null);
+
+        /** Node startTime */
+        startTime?: (number|null);
+
+        /** Node endTime */
+        endTime?: (number|null);
+
+        /** Node error */
+        error?: (Trace.IError[]|null);
+
+        /** Node child */
+        child?: (Trace.INode[]|null);
+    }
+
+    /** Represents a Node. */
+    class Node implements INode {
+
+        /**
+         * Constructs a new Node.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.INode);
+
+        /** Node responseName. */
+        public responseName: string;
+
+        /** Node index. */
+        public index: number;
+
+        /** Node originalFieldName. */
+        public originalFieldName: string;
+
+        /** Node type. */
+        public type: string;
+
+        /** Node parentType. */
+        public parentType: string;
+
+        /** Node cachePolicy. */
+        public cachePolicy?: (Trace.ICachePolicy|null);
+
+        /** Node startTime. */
+        public startTime: number;
+
+        /** Node endTime. */
+        public endTime: number;
+
+        /** Node error. */
+        public error: Trace.IError[];
+
+        /** Node child. */
+        public child: Trace.INode[];
+
+        /** Node id. */
+        public id?: ("responseName"|"index");
+
+        /**
+         * Creates a new Node instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns Node instance
+         */
+        public static create(properties?: Trace.INode): Trace.Node;
+
+        /**
+         * Encodes the specified Node message. Does not implicitly {@link Trace.Node.verify|verify} messages.
+         * @param message Node message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.INode, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified Node message, length delimited. Does not implicitly {@link Trace.Node.verify|verify} messages.
+         * @param message Node message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.INode, writer?: Writer): Writer;
+
+        /**
+         * Decodes a Node message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns Node
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.Node;
+
+        /**
+         * Decodes a Node message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns Node
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.Node;
+
+        /**
+         * Verifies a Node message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from a Node message. Also converts values to other types if specified.
+         * @param message Node
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.Node, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this Node to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    /** Properties of a QueryPlanNode. */
+    interface IQueryPlanNode {
+
+        /** QueryPlanNode sequence */
+        sequence?: (Trace.QueryPlanNode.ISequenceNode|null);
+
+        /** QueryPlanNode parallel */
+        parallel?: (Trace.QueryPlanNode.IParallelNode|null);
+
+        /** QueryPlanNode fetch */
+        fetch?: (Trace.QueryPlanNode.IFetchNode|null);
+
+        /** QueryPlanNode flatten */
+        flatten?: (Trace.QueryPlanNode.IFlattenNode|null);
+
+        /** QueryPlanNode defer */
+        defer?: (Trace.QueryPlanNode.IDeferNode|null);
+
+        /** QueryPlanNode condition */
+        condition?: (Trace.QueryPlanNode.IConditionNode|null);
+    }
+
+    /** Represents a QueryPlanNode. */
+    class QueryPlanNode implements IQueryPlanNode {
+
+        /**
+         * Constructs a new QueryPlanNode.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: Trace.IQueryPlanNode);
+
+        /** QueryPlanNode sequence. */
+        public sequence?: (Trace.QueryPlanNode.ISequenceNode|null);
+
+        /** QueryPlanNode parallel. */
+        public parallel?: (Trace.QueryPlanNode.IParallelNode|null);
+
+        /** QueryPlanNode fetch. */
+        public fetch?: (Trace.QueryPlanNode.IFetchNode|null);
+
+        /** QueryPlanNode flatten. */
+        public flatten?: (Trace.QueryPlanNode.IFlattenNode|null);
+
+        /** QueryPlanNode defer. */
+        public defer?: (Trace.QueryPlanNode.IDeferNode|null);
+
+        /** QueryPlanNode condition. */
+        public condition?: (Trace.QueryPlanNode.IConditionNode|null);
+
+        /** QueryPlanNode node. */
+        public node?: ("sequence"|"parallel"|"fetch"|"flatten"|"defer"|"condition");
+
+        /**
+         * Creates a new QueryPlanNode instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns QueryPlanNode instance
+         */
+        public static create(properties?: Trace.IQueryPlanNode): Trace.QueryPlanNode;
+
+        /**
+         * Encodes the specified QueryPlanNode message. Does not implicitly {@link Trace.QueryPlanNode.verify|verify} messages.
+         * @param message QueryPlanNode message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: Trace.IQueryPlanNode, writer?: Writer): Writer;
+
+        /**
+         * Encodes the specified QueryPlanNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.verify|verify} messages.
+         * @param message QueryPlanNode message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: Trace.IQueryPlanNode, writer?: Writer): Writer;
+
+        /**
+         * Decodes a QueryPlanNode message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns QueryPlanNode
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode;
+
+        /**
+         * Decodes a QueryPlanNode message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns QueryPlanNode
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode;
+
+        /**
+         * Verifies a QueryPlanNode message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Creates a plain object from a QueryPlanNode message. Also converts values to other types if specified.
+         * @param message QueryPlanNode
+         * @param [options] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(message: Trace.QueryPlanNode, options?: IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this QueryPlanNode to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+
+    namespace QueryPlanNode {
+
+        /** Properties of a SequenceNode. */
+        interface ISequenceNode {
+
+            /** SequenceNode nodes */
+            nodes?: (Trace.IQueryPlanNode[]|null);
+        }
+
+        /** Represents a SequenceNode. */
+        class SequenceNode implements ISequenceNode {
+
+            /**
+             * Constructs a new SequenceNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.ISequenceNode);
+
+            /** SequenceNode nodes. */
+            public nodes: Trace.IQueryPlanNode[];
+
+            /**
+             * Creates a new SequenceNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns SequenceNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.ISequenceNode): Trace.QueryPlanNode.SequenceNode;
+
+            /**
+             * Encodes the specified SequenceNode message. Does not implicitly {@link Trace.QueryPlanNode.SequenceNode.verify|verify} messages.
+             * @param message SequenceNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.ISequenceNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified SequenceNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.SequenceNode.verify|verify} messages.
+             * @param message SequenceNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.ISequenceNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a SequenceNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns SequenceNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.SequenceNode;
+
+            /**
+             * Decodes a SequenceNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns SequenceNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.SequenceNode;
+
+            /**
+             * Verifies a SequenceNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a SequenceNode message. Also converts values to other types if specified.
+             * @param message SequenceNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.SequenceNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this SequenceNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a ParallelNode. */
+        interface IParallelNode {
+
+            /** ParallelNode nodes */
+            nodes?: (Trace.IQueryPlanNode[]|null);
+        }
+
+        /** Represents a ParallelNode. */
+        class ParallelNode implements IParallelNode {
+
+            /**
+             * Constructs a new ParallelNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IParallelNode);
+
+            /** ParallelNode nodes. */
+            public nodes: Trace.IQueryPlanNode[];
+
+            /**
+             * Creates a new ParallelNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns ParallelNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IParallelNode): Trace.QueryPlanNode.ParallelNode;
+
+            /**
+             * Encodes the specified ParallelNode message. Does not implicitly {@link Trace.QueryPlanNode.ParallelNode.verify|verify} messages.
+             * @param message ParallelNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IParallelNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified ParallelNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.ParallelNode.verify|verify} messages.
+             * @param message ParallelNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IParallelNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a ParallelNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns ParallelNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.ParallelNode;
+
+            /**
+             * Decodes a ParallelNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns ParallelNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.ParallelNode;
+
+            /**
+             * Verifies a ParallelNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a ParallelNode message. Also converts values to other types if specified.
+             * @param message ParallelNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.ParallelNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this ParallelNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a FetchNode. */
+        interface IFetchNode {
+
+            /** FetchNode serviceName */
+            serviceName?: (string|null);
+
+            /** FetchNode traceParsingFailed */
+            traceParsingFailed?: (boolean|null);
+
+            /** FetchNode trace */
+            trace?: (ITrace|null);
+
+            /** FetchNode sentTimeOffset */
+            sentTimeOffset?: (number|null);
+
+            /** FetchNode sentTime */
+            sentTime?: (google.protobuf.ITimestamp|null);
+
+            /** FetchNode receivedTime */
+            receivedTime?: (google.protobuf.ITimestamp|null);
+        }
+
+        /** Represents a FetchNode. */
+        class FetchNode implements IFetchNode {
+
+            /**
+             * Constructs a new FetchNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IFetchNode);
+
+            /** FetchNode serviceName. */
+            public serviceName: string;
+
+            /** FetchNode traceParsingFailed. */
+            public traceParsingFailed: boolean;
+
+            /** FetchNode trace. */
+            public trace?: (ITrace|null);
+
+            /** FetchNode sentTimeOffset. */
+            public sentTimeOffset: number;
+
+            /** FetchNode sentTime. */
+            public sentTime?: (google.protobuf.ITimestamp|null);
+
+            /** FetchNode receivedTime. */
+            public receivedTime?: (google.protobuf.ITimestamp|null);
+
+            /**
+             * Creates a new FetchNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns FetchNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IFetchNode): Trace.QueryPlanNode.FetchNode;
+
+            /**
+             * Encodes the specified FetchNode message. Does not implicitly {@link Trace.QueryPlanNode.FetchNode.verify|verify} messages.
+             * @param message FetchNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IFetchNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified FetchNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.FetchNode.verify|verify} messages.
+             * @param message FetchNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IFetchNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a FetchNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns FetchNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.FetchNode;
+
+            /**
+             * Decodes a FetchNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns FetchNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.FetchNode;
+
+            /**
+             * Verifies a FetchNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a FetchNode message. Also converts values to other types if specified.
+             * @param message FetchNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.FetchNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this FetchNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a FlattenNode. */
+        interface IFlattenNode {
+
+            /** FlattenNode responsePath */
+            responsePath?: (Trace.QueryPlanNode.IResponsePathElement[]|null);
+
+            /** FlattenNode node */
+            node?: (Trace.IQueryPlanNode|null);
+        }
+
+        /** Represents a FlattenNode. */
+        class FlattenNode implements IFlattenNode {
+
+            /**
+             * Constructs a new FlattenNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IFlattenNode);
+
+            /** FlattenNode responsePath. */
+            public responsePath: Trace.QueryPlanNode.IResponsePathElement[];
+
+            /** FlattenNode node. */
+            public node?: (Trace.IQueryPlanNode|null);
+
+            /**
+             * Creates a new FlattenNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns FlattenNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IFlattenNode): Trace.QueryPlanNode.FlattenNode;
+
+            /**
+             * Encodes the specified FlattenNode message. Does not implicitly {@link Trace.QueryPlanNode.FlattenNode.verify|verify} messages.
+             * @param message FlattenNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IFlattenNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified FlattenNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.FlattenNode.verify|verify} messages.
+             * @param message FlattenNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IFlattenNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a FlattenNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns FlattenNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.FlattenNode;
+
+            /**
+             * Decodes a FlattenNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns FlattenNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.FlattenNode;
+
+            /**
+             * Verifies a FlattenNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a FlattenNode message. Also converts values to other types if specified.
+             * @param message FlattenNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.FlattenNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this FlattenNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a DeferNode. */
+        interface IDeferNode {
+
+            /** DeferNode primary */
+            primary?: (Trace.QueryPlanNode.IDeferNodePrimary|null);
+
+            /** DeferNode deferred */
+            deferred?: (Trace.QueryPlanNode.IDeferredNode[]|null);
+        }
+
+        /** Represents a DeferNode. */
+        class DeferNode implements IDeferNode {
+
+            /**
+             * Constructs a new DeferNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IDeferNode);
+
+            /** DeferNode primary. */
+            public primary?: (Trace.QueryPlanNode.IDeferNodePrimary|null);
+
+            /** DeferNode deferred. */
+            public deferred: Trace.QueryPlanNode.IDeferredNode[];
+
+            /**
+             * Creates a new DeferNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns DeferNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IDeferNode): Trace.QueryPlanNode.DeferNode;
+
+            /**
+             * Encodes the specified DeferNode message. Does not implicitly {@link Trace.QueryPlanNode.DeferNode.verify|verify} messages.
+             * @param message DeferNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IDeferNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified DeferNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.DeferNode.verify|verify} messages.
+             * @param message DeferNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IDeferNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a DeferNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns DeferNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.DeferNode;
+
+            /**
+             * Decodes a DeferNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns DeferNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.DeferNode;
+
+            /**
+             * Verifies a DeferNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a DeferNode message. Also converts values to other types if specified.
+             * @param message DeferNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.DeferNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this DeferNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a ConditionNode. */
+        interface IConditionNode {
+
+            /** ConditionNode condition */
+            condition?: (string|null);
+
+            /** ConditionNode ifClause */
+            ifClause?: (Trace.IQueryPlanNode|null);
+
+            /** ConditionNode elseClause */
+            elseClause?: (Trace.IQueryPlanNode|null);
+        }
+
+        /** Represents a ConditionNode. */
+        class ConditionNode implements IConditionNode {
+
+            /**
+             * Constructs a new ConditionNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IConditionNode);
+
+            /** ConditionNode condition. */
+            public condition: string;
+
+            /** ConditionNode ifClause. */
+            public ifClause?: (Trace.IQueryPlanNode|null);
+
+            /** ConditionNode elseClause. */
+            public elseClause?: (Trace.IQueryPlanNode|null);
+
+            /**
+             * Creates a new ConditionNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns ConditionNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IConditionNode): Trace.QueryPlanNode.ConditionNode;
+
+            /**
+             * Encodes the specified ConditionNode message. Does not implicitly {@link Trace.QueryPlanNode.ConditionNode.verify|verify} messages.
+             * @param message ConditionNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IConditionNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified ConditionNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.ConditionNode.verify|verify} messages.
+             * @param message ConditionNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IConditionNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a ConditionNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns ConditionNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.ConditionNode;
+
+            /**
+             * Decodes a ConditionNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns ConditionNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.ConditionNode;
+
+            /**
+             * Verifies a ConditionNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a ConditionNode message. Also converts values to other types if specified.
+             * @param message ConditionNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.ConditionNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this ConditionNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a DeferNodePrimary. */
+        interface IDeferNodePrimary {
+
+            /** DeferNodePrimary node */
+            node?: (Trace.IQueryPlanNode|null);
+        }
+
+        /** Represents a DeferNodePrimary. */
+        class DeferNodePrimary implements IDeferNodePrimary {
+
+            /**
+             * Constructs a new DeferNodePrimary.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IDeferNodePrimary);
+
+            /** DeferNodePrimary node. */
+            public node?: (Trace.IQueryPlanNode|null);
+
+            /**
+             * Creates a new DeferNodePrimary instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns DeferNodePrimary instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IDeferNodePrimary): Trace.QueryPlanNode.DeferNodePrimary;
+
+            /**
+             * Encodes the specified DeferNodePrimary message. Does not implicitly {@link Trace.QueryPlanNode.DeferNodePrimary.verify|verify} messages.
+             * @param message DeferNodePrimary message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IDeferNodePrimary, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified DeferNodePrimary message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.DeferNodePrimary.verify|verify} messages.
+             * @param message DeferNodePrimary message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IDeferNodePrimary, writer?: Writer): Writer;
+
+            /**
+             * Decodes a DeferNodePrimary message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns DeferNodePrimary
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.DeferNodePrimary;
+
+            /**
+             * Decodes a DeferNodePrimary message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns DeferNodePrimary
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.DeferNodePrimary;
+
+            /**
+             * Verifies a DeferNodePrimary message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a DeferNodePrimary message. Also converts values to other types if specified.
+             * @param message DeferNodePrimary
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.DeferNodePrimary, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this DeferNodePrimary to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a DeferredNode. */
+        interface IDeferredNode {
+
+            /** DeferredNode depends */
+            depends?: (Trace.QueryPlanNode.IDeferredNodeDepends[]|null);
+
+            /** DeferredNode label */
+            label?: (string|null);
+
+            /** DeferredNode path */
+            path?: (Trace.QueryPlanNode.IResponsePathElement[]|null);
+
+            /** DeferredNode node */
+            node?: (Trace.IQueryPlanNode|null);
+        }
+
+        /** Represents a DeferredNode. */
+        class DeferredNode implements IDeferredNode {
+
+            /**
+             * Constructs a new DeferredNode.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IDeferredNode);
+
+            /** DeferredNode depends. */
+            public depends: Trace.QueryPlanNode.IDeferredNodeDepends[];
+
+            /** DeferredNode label. */
+            public label: string;
+
+            /** DeferredNode path. */
+            public path: Trace.QueryPlanNode.IResponsePathElement[];
+
+            /** DeferredNode node. */
+            public node?: (Trace.IQueryPlanNode|null);
+
+            /**
+             * Creates a new DeferredNode instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns DeferredNode instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IDeferredNode): Trace.QueryPlanNode.DeferredNode;
+
+            /**
+             * Encodes the specified DeferredNode message. Does not implicitly {@link Trace.QueryPlanNode.DeferredNode.verify|verify} messages.
+             * @param message DeferredNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IDeferredNode, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified DeferredNode message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.DeferredNode.verify|verify} messages.
+             * @param message DeferredNode message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IDeferredNode, writer?: Writer): Writer;
+
+            /**
+             * Decodes a DeferredNode message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns DeferredNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.DeferredNode;
+
+            /**
+             * Decodes a DeferredNode message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns DeferredNode
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.DeferredNode;
+
+            /**
+             * Verifies a DeferredNode message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a DeferredNode message. Also converts values to other types if specified.
+             * @param message DeferredNode
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.DeferredNode, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this DeferredNode to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a DeferredNodeDepends. */
+        interface IDeferredNodeDepends {
+
+            /** DeferredNodeDepends id */
+            id?: (string|null);
+
+            /** DeferredNodeDepends deferLabel */
+            deferLabel?: (string|null);
+        }
+
+        /** Represents a DeferredNodeDepends. */
+        class DeferredNodeDepends implements IDeferredNodeDepends {
+
+            /**
+             * Constructs a new DeferredNodeDepends.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IDeferredNodeDepends);
+
+            /** DeferredNodeDepends id. */
+            public id: string;
+
+            /** DeferredNodeDepends deferLabel. */
+            public deferLabel: string;
+
+            /**
+             * Creates a new DeferredNodeDepends instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns DeferredNodeDepends instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IDeferredNodeDepends): Trace.QueryPlanNode.DeferredNodeDepends;
+
+            /**
+             * Encodes the specified DeferredNodeDepends message. Does not implicitly {@link Trace.QueryPlanNode.DeferredNodeDepends.verify|verify} messages.
+             * @param message DeferredNodeDepends message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IDeferredNodeDepends, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified DeferredNodeDepends message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.DeferredNodeDepends.verify|verify} messages.
+             * @param message DeferredNodeDepends message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IDeferredNodeDepends, writer?: Writer): Writer;
+
+            /**
+             * Decodes a DeferredNodeDepends message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns DeferredNodeDepends
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.DeferredNodeDepends;
+
+            /**
+             * Decodes a DeferredNodeDepends message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns DeferredNodeDepends
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.DeferredNodeDepends;
+
+            /**
+             * Verifies a DeferredNodeDepends message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a DeferredNodeDepends message. Also converts values to other types if specified.
+             * @param message DeferredNodeDepends
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.DeferredNodeDepends, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this DeferredNodeDepends to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+
+        /** Properties of a ResponsePathElement. */
+        interface IResponsePathElement {
+
+            /** ResponsePathElement fieldName */
+            fieldName?: (string|null);
+
+            /** ResponsePathElement index */
+            index?: (number|null);
+        }
+
+        /** Represents a ResponsePathElement. */
+        class ResponsePathElement implements IResponsePathElement {
+
+            /**
+             * Constructs a new ResponsePathElement.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: Trace.QueryPlanNode.IResponsePathElement);
+
+            /** ResponsePathElement fieldName. */
+            public fieldName: string;
+
+            /** ResponsePathElement index. */
+            public index: number;
+
+            /** ResponsePathElement id. */
+            public id?: ("fieldName"|"index");
+
+            /**
+             * Creates a new ResponsePathElement instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns ResponsePathElement instance
+             */
+            public static create(properties?: Trace.QueryPlanNode.IResponsePathElement): Trace.QueryPlanNode.ResponsePathElement;
+
+            /**
+             * Encodes the specified ResponsePathElement message. Does not implicitly {@link Trace.QueryPlanNode.ResponsePathElement.verify|verify} messages.
+             * @param message ResponsePathElement message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: Trace.QueryPlanNode.IResponsePathElement, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified ResponsePathElement message, length delimited. Does not implicitly {@link Trace.QueryPlanNode.ResponsePathElement.verify|verify} messages.
+             * @param message ResponsePathElement message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: Trace.QueryPlanNode.IResponsePathElement, writer?: Writer): Writer;
+
+            /**
+             * Decodes a ResponsePathElement message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns ResponsePathElement
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): Trace.QueryPlanNode.ResponsePathElement;
+
+            /**
+             * Decodes a ResponsePathElement message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns ResponsePathElement
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): Trace.QueryPlanNode.ResponsePathElement;
+
+            /**
+             * Verifies a ResponsePathElement message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a ResponsePathElement message. Also converts values to other types if specified.
+             * @param message ResponsePathElement
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: Trace.QueryPlanNode.ResponsePathElement, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this ResponsePathElement to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+    }
+}
+
+/** Namespace google. */
+declare namespace google {
+
+    /** Namespace protobuf. */
+    namespace protobuf {
+
+        /** Properties of a Timestamp. */
+        interface ITimestamp {
+
+            /** Timestamp seconds */
+            seconds?: (number|null);
+
+            /** Timestamp nanos */
+            nanos?: (number|null);
+        }
+
+        /** Represents a Timestamp. */
+        class Timestamp implements ITimestamp {
+
+            /**
+             * Constructs a new Timestamp.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: google.protobuf.ITimestamp);
+
+            /** Timestamp seconds. */
+            public seconds: number;
+
+            /** Timestamp nanos. */
+            public nanos: number;
+
+            /**
+             * Creates a new Timestamp instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns Timestamp instance
+             */
+            public static create(properties?: google.protobuf.ITimestamp): google.protobuf.Timestamp;
+
+            /**
+             * Encodes the specified Timestamp message. Does not implicitly {@link google.protobuf.Timestamp.verify|verify} messages.
+             * @param message Timestamp message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: google.protobuf.ITimestamp, writer?: Writer): Writer;
+
+            /**
+             * Encodes the specified Timestamp message, length delimited. Does not implicitly {@link google.protobuf.Timestamp.verify|verify} messages.
+             * @param message Timestamp message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encodeDelimited(message: google.protobuf.ITimestamp, writer?: Writer): Writer;
+
+            /**
+             * Decodes a Timestamp message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns Timestamp
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: (Reader|Uint8Array), length?: number): google.protobuf.Timestamp;
+
+            /**
+             * Decodes a Timestamp message from the specified reader or buffer, length delimited.
+             * @param reader Reader or buffer to decode from
+             * @returns Timestamp
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decodeDelimited(reader: (Reader|Uint8Array)): google.protobuf.Timestamp;
+
+            /**
+             * Verifies a Timestamp message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+
+            /**
+             * Creates a plain object from a Timestamp message. Also converts values to other types if specified.
+             * @param message Timestamp
+             * @param [options] Conversion options
+             * @returns Plain object
+             */
+            public static toObject(message: google.protobuf.Timestamp, options?: IConversionOptions): { [k: string]: any };
+
+            /**
+             * Converts this Timestamp to JSON.
+             * @returns JSON object
+             */
+            public toJSON(): { [k: string]: any };
+        }
+    }
+}
+
+type CacheScope = 'PUBLIC' | 'PRIVATE';
+interface CacheHint {
+    maxAge?: number;
+    scope?: CacheScope;
+}
+interface CachePolicy extends CacheHint {
+    replace(hint: CacheHint): void;
+    restrict(hint: CacheHint): void;
+    policyIfCacheable(): Required<CacheHint> | null;
+}
+
+interface GraphQLRequestMetrics {
+    captureTraces?: boolean;
+    persistedQueryHit?: boolean;
+    persistedQueryRegister?: boolean;
+    responseCacheHit?: boolean;
+    forbiddenOperation?: boolean;
+    registeredOperation?: boolean;
+    startHrTime?: [number, number];
+    queryPlanTrace?: Trace.QueryPlanNode;
+    nonFtv1ErrorPaths?: NonFtv1ErrorPath[];
+}
+interface GraphQLRequestContext<TContext extends BaseContext> {
+    readonly logger: Logger;
+    readonly cache: KeyValueCache<string>;
+    readonly request: GraphQLRequest;
+    readonly response: GraphQLInProgressResponse;
+    readonly schema: GraphQLSchema;
+    readonly contextValue: TContext;
+    readonly queryHash?: string;
+    readonly document?: DocumentNode;
+    readonly source?: string;
+    readonly operationName?: string | null;
+    readonly operation?: OperationDefinitionNode;
+    readonly errors?: ReadonlyArray<GraphQLError>;
+    readonly metrics: GraphQLRequestMetrics;
+    readonly overallCachePolicy: CachePolicy;
+    readonly requestIsBatched: boolean;
+}
+type GraphQLRequestContextDidResolveSource<TContext extends BaseContext> = WithRequired<GraphQLRequestContext<TContext>, 'source' | 'queryHash'>;
+type GraphQLRequestContextParsingDidStart<TContext extends BaseContext> = GraphQLRequestContextDidResolveSource<TContext>;
+type GraphQLRequestContextValidationDidStart<TContext extends BaseContext> = GraphQLRequestContextParsingDidStart<TContext> & WithRequired<GraphQLRequestContext<TContext>, 'document'>;
+type GraphQLRequestContextDidResolveOperation<TContext extends BaseContext> = GraphQLRequestContextValidationDidStart<TContext> & WithRequired<GraphQLRequestContext<TContext>, 'operationName'>;
+type GraphQLRequestContextDidEncounterErrors<TContext extends BaseContext> = WithRequired<GraphQLRequestContext<TContext>, 'errors'>;
+type GraphQLRequestContextResponseForOperation<TContext extends BaseContext> = WithRequired<GraphQLRequestContext<TContext>, 'source' | 'document' | 'operation' | 'operationName'>;
+type GraphQLRequestContextExecutionDidStart<TContext extends BaseContext> = GraphQLRequestContextParsingDidStart<TContext> & WithRequired<GraphQLRequestContext<TContext>, 'document' | 'operation' | 'operationName'>;
+type GraphQLRequestContextWillSendResponse<TContext extends BaseContext> = GraphQLRequestContextDidResolveSource<TContext> & {
+    readonly response: GraphQLResponse;
+};
+type GraphQLRequestContextDidEncounterSubsequentErrors<TContext extends BaseContext> = GraphQLRequestContextWillSendResponse<TContext>;
+type GraphQLRequestContextWillSendSubsequentPayload<TContext extends BaseContext> = GraphQLRequestContextWillSendResponse<TContext>;
+
+interface GraphQLServerContext {
+    readonly logger: Logger;
+    readonly cache: KeyValueCache<string>;
+    schema: GraphQLSchema;
+    apollo: ApolloConfig;
+    startedInBackground: boolean;
+}
+interface GraphQLSchemaContext {
+    apiSchema: GraphQLSchema;
+    coreSupergraphSdl?: string;
+}
+interface ApolloServerPlugin<in TContext extends BaseContext = BaseContext> {
+    serverWillStart?(service: GraphQLServerContext): Promise<GraphQLServerListener | void>;
+    requestDidStart?(requestContext: GraphQLRequestContext<TContext>): Promise<GraphQLRequestListener<TContext> | void>;
+    unexpectedErrorProcessingRequest?({ requestContext, error, }: {
+        requestContext: GraphQLRequestContext<TContext>;
+        error: Error;
+    }): Promise<void>;
+    contextCreationDidFail?({ error }: {
+        error: Error;
+    }): Promise<void>;
+    invalidRequestWasReceived?({ error }: {
+        error: Error;
+    }): Promise<void>;
+    startupDidFail?({ error }: {
+        error: Error;
+    }): Promise<void>;
+}
+interface GraphQLServerListener {
+    schemaDidLoadOrUpdate?(schemaContext: GraphQLSchemaContext): void;
+    drainServer?(): Promise<void>;
+    serverWillStop?(): Promise<void>;
+    renderLandingPage?(): Promise<LandingPage>;
+}
+interface LandingPage {
+    html: string | (() => Promise<string>);
+}
+type GraphQLRequestListenerParsingDidEnd = (err?: Error) => Promise<void>;
+type GraphQLRequestListenerValidationDidEnd = (err?: ReadonlyArray<Error>) => Promise<void>;
+type GraphQLRequestListenerExecutionDidEnd = (err?: Error) => Promise<void>;
+type GraphQLRequestListenerDidResolveField = (error: Error | null, result?: any) => void;
+interface GraphQLRequestListener<TContext extends BaseContext> {
+    didResolveSource?(requestContext: GraphQLRequestContextDidResolveSource<TContext>): Promise<void>;
+    parsingDidStart?(requestContext: GraphQLRequestContextParsingDidStart<TContext>): Promise<GraphQLRequestListenerParsingDidEnd | void>;
+    validationDidStart?(requestContext: GraphQLRequestContextValidationDidStart<TContext>): Promise<GraphQLRequestListenerValidationDidEnd | void>;
+    didResolveOperation?(requestContext: GraphQLRequestContextDidResolveOperation<TContext>): Promise<void>;
+    didEncounterErrors?(requestContext: GraphQLRequestContextDidEncounterErrors<TContext>): Promise<void>;
+    responseForOperation?(requestContext: GraphQLRequestContextResponseForOperation<TContext>): Promise<GraphQLResponse | null>;
+    executionDidStart?(requestContext: GraphQLRequestContextExecutionDidStart<TContext>): Promise<GraphQLRequestExecutionListener<TContext> | void>;
+    willSendResponse?(requestContext: GraphQLRequestContextWillSendResponse<TContext>): Promise<void>;
+    didEncounterSubsequentErrors?(requestContext: GraphQLRequestContextDidEncounterSubsequentErrors<TContext>, errors: ReadonlyArray<GraphQLError>): Promise<void>;
+    willSendSubsequentPayload?(requestContext: GraphQLRequestContextWillSendSubsequentPayload<TContext>, payload: GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult): Promise<void>;
+}
+type GraphQLFieldResolverParams<TSource, TContext, TArgs = {
+    [argName: string]: any;
+}> = {
+    source: TSource;
+    args: TArgs;
+    contextValue: TContext;
+    info: GraphQLResolveInfo;
+};
+interface GraphQLRequestExecutionListener<TContext extends BaseContext> {
+    executionDidEnd?: GraphQLRequestListenerExecutionDidEnd;
+    willResolveField?(fieldResolverParams: GraphQLFieldResolverParams<any, TContext>): GraphQLRequestListenerDidResolveField | void;
+}
+
+interface Options {
+    serviceName: string;
+    token: string;
+}
+declare const createStellateLoggerPlugin: (options: Options) => ApolloServerPlugin;
+
+export { createStellateLoggerPlugin };