apollo-language-server

  • Version 1.26.9
  • Published
  • 750 kB
  • 25 dependencies
  • MIT license

Install

npm i apollo-language-server
yarn add apollo-language-server
pnpm add apollo-language-server

Overview

A language server for Apollo GraphQL projects

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable DefaultClientConfig

const DefaultClientConfig: {
tagName: string;
clientOnlyDirectives: string[];
clientSchemaDirectives: string[];
addTypename: boolean;
statsWindow: { to: number; from: number };
includes: string[];
excludes: string[];
};

    variable DefaultConfigBase

    const DefaultConfigBase: { includes: string[]; excludes: string[] };

      variable DefaultEngineConfig

      const DefaultEngineConfig: { endpoint: string };

        variable DefaultEngineStatsWindow

        const DefaultEngineStatsWindow: { to: number; from: number };

          variable DefaultServiceConfig

          const DefaultServiceConfig: {
          endpoint: { url: string };
          includes: string[];
          excludes: string[];
          };

            variable keyEnvVar

            const keyEnvVar: string;

              variable legacyKeyEnvVar

              const legacyKeyEnvVar: string;

                Functions

                function getGraphIdFromConfig

                getGraphIdFromConfig: (config: ApolloConfigFormat) => string | undefined;

                  function getServiceFromKey

                  getServiceFromKey: (key?: string) => string | undefined;

                    function getValidationErrors

                    getValidationErrors: (
                    schema: GraphQLSchema,
                    document: DocumentNode,
                    fragments?: { [fragmentName: string]: FragmentDefinitionNode },
                    rules?: ValidationRule[]
                    ) => any;

                      function isClientConfig

                      isClientConfig: (config: ApolloConfig) => config is ClientConfig;

                        function isClientProject

                        isClientProject: (project: GraphQLProject) => project is GraphQLClientProject;

                          function isLocalServiceConfig

                          isLocalServiceConfig: (
                          config: ClientServiceConfig
                          ) => config is LocalServiceConfig;

                            function isServiceConfig

                            isServiceConfig: (config: ApolloConfig) => config is ServiceConfig;

                              function isServiceKey

                              isServiceKey: (key?: string) => boolean | '' | undefined;

                                function isServiceProject

                                isServiceProject: (project: GraphQLProject) => project is GraphQLServiceProject;

                                  function loadConfig

                                  loadConfig: ({
                                  configPath,
                                  configFileName,
                                  requireConfig,
                                  name,
                                  type,
                                  }: LoadConfigSettings) => Promise<void | ApolloConfig>;

                                    function noServiceError

                                    noServiceError: (service: string | undefined, endpoint?: string) => string;

                                      function parseServiceSpecifier

                                      parseServiceSpecifier: (specifier: ServiceSpecifier) => ServiceIDAndTag;

                                        function schemaProviderFromConfig

                                        schemaProviderFromConfig: (
                                        config: ApolloConfig,
                                        clientIdentity?: ClientIdentity
                                        ) => GraphQLSchemaProvider;

                                          function withTypenameFieldAddedWhereNeeded

                                          withTypenameFieldAddedWhereNeeded: (ast: ASTNode) => any;

                                            Classes

                                            class ApolloConfig

                                            class ApolloConfig {}

                                              constructor

                                              constructor(rawConfig: any, configURI?: any);

                                                property client

                                                client?: ClientConfigFormat;

                                                  property configDirURI

                                                  readonly configDirURI: any;

                                                    property configURI

                                                    configURI?: any;

                                                      property engine

                                                      engine: EngineConfig;

                                                        property graph

                                                        graph: string;

                                                          property isClient

                                                          isClient: boolean;

                                                            property isService

                                                            isService: boolean;

                                                              property projects

                                                              readonly projects: (ClientConfig | ServiceConfig)[];

                                                                property rawConfig

                                                                rawConfig: any;

                                                                  property service

                                                                  service?: ServiceConfigFormat;

                                                                    property variant

                                                                    variant: string;

                                                                      method setDefaults

                                                                      setDefaults: ({ client, engine, service }: any) => void;

                                                                        class ApolloEngineClient

                                                                        class ApolloEngineClient extends GraphQLDataSource {}

                                                                          constructor

                                                                          constructor(
                                                                          engineKey: string,
                                                                          engineEndpoint?: string,
                                                                          clientIdentity?: ClientIdentity
                                                                          );

                                                                            method checkPartialSchema

                                                                            checkPartialSchema: (
                                                                            variables: CheckPartialSchemaVariables
                                                                            ) => Promise<CheckPartialSchema_service_checkPartialSchema>;

                                                                              method checkSchema

                                                                              checkSchema: (
                                                                              variables: CheckSchemaVariables
                                                                              ) => Promise<import('../graphqlTypes').CheckSchema_service_checkSchema>;

                                                                                method listServices

                                                                                listServices: (variables: ListServicesVariables) => Promise<ListServices>;

                                                                                  method loadSchemaTagsAndFieldStats

                                                                                  loadSchemaTagsAndFieldStats: (
                                                                                  serviceID: string
                                                                                  ) => Promise<{ schemaTags: string[]; fieldStats: FieldStats }>;

                                                                                    method registerOperations

                                                                                    registerOperations: (
                                                                                    variables: RegisterOperationsVariables
                                                                                    ) => Promise<
                                                                                    import('../graphqlTypes').RegisterOperations_service_registerOperationsWithResponse
                                                                                    >;

                                                                                      method removeServiceAndCompose

                                                                                      removeServiceAndCompose: (
                                                                                      variables: RemoveServiceAndComposeVariables
                                                                                      ) => Promise<
                                                                                      import('../graphqlTypes').RemoveServiceAndCompose_service_removeImplementingServiceAndTriggerComposition
                                                                                      >;

                                                                                        method uploadAndComposePartialSchema

                                                                                        uploadAndComposePartialSchema: (
                                                                                        variables: UploadAndComposePartialSchemaVariables
                                                                                        ) => Promise<
                                                                                        import('../graphqlTypes').UploadAndComposePartialSchema_service_upsertImplementingServiceAndTriggerComposition
                                                                                        >;

                                                                                          method uploadSchema

                                                                                          uploadSchema: (
                                                                                          variables: UploadSchemaVariables
                                                                                          ) => Promise<import('../graphqlTypes').UploadSchema_service_uploadSchema | null>;

                                                                                            method validateOperations

                                                                                            validateOperations: (
                                                                                            variables: ValidateOperationsVariables
                                                                                            ) => Promise<
                                                                                            import('../graphqlTypes').ValidateOperations_service_validateOperations_validationResults[]
                                                                                            >;

                                                                                              method willSendRequest

                                                                                              willSendRequest: (request: any) => void;

                                                                                                class ClientConfig

                                                                                                class ClientConfig extends ApolloConfig {}

                                                                                                  property client

                                                                                                  client: ClientConfigFormat;

                                                                                                    class Debug

                                                                                                    class Debug {}

                                                                                                      method error

                                                                                                      static error: (message: string) => void;

                                                                                                        method info

                                                                                                        static info: (message: string) => void;

                                                                                                          method sendErrorTelemetry

                                                                                                          static sendErrorTelemetry: (message: string) => void;

                                                                                                            method SetConnection

                                                                                                            static SetConnection: (conn: Connection) => void;

                                                                                                              method SetLoggers

                                                                                                              static SetLoggers: ({
                                                                                                              info,
                                                                                                              warning,
                                                                                                              error,
                                                                                                              }: {
                                                                                                              info?: Logger;
                                                                                                              warning?: Logger;
                                                                                                              error?: Logger;
                                                                                                              }) => void;

                                                                                                                method warning

                                                                                                                static warning: (message: string) => void;

                                                                                                                  class GraphQLClientProject

                                                                                                                  class GraphQLClientProject extends GraphQLProject {}

                                                                                                                    constructor

                                                                                                                    constructor({
                                                                                                                    config,
                                                                                                                    loadingHandler,
                                                                                                                    rootURI,
                                                                                                                    clientIdentity,
                                                                                                                    }: GraphQLClientProjectConfig);

                                                                                                                      property clientSchema

                                                                                                                      readonly clientSchema: DocumentNode;

                                                                                                                        property config

                                                                                                                        config: ClientConfig;

                                                                                                                          property diagnosticSet

                                                                                                                          diagnosticSet?: DiagnosticSet;

                                                                                                                            property displayName

                                                                                                                            readonly displayName: string;

                                                                                                                              property fragments

                                                                                                                              readonly fragments: { [fragmentName: string]: FragmentDefinitionNode };

                                                                                                                                property mergedOperationsAndFragments

                                                                                                                                readonly mergedOperationsAndFragments: { [operationName: string]: DocumentNode };

                                                                                                                                  property mergedOperationsAndFragmentsForService

                                                                                                                                  readonly mergedOperationsAndFragmentsForService: {
                                                                                                                                  [operationName: string]: DocumentNode;
                                                                                                                                  };

                                                                                                                                    property missingApolloClientDirectives

                                                                                                                                    readonly missingApolloClientDirectives: readonly DefinitionNode[];

                                                                                                                                      property operations

                                                                                                                                      readonly operations: { [operationName: string]: OperationDefinitionNode };

                                                                                                                                        property rootURI

                                                                                                                                        rootURI: URI;

                                                                                                                                          property serviceID

                                                                                                                                          serviceID?: string;

                                                                                                                                            method fragmentSpreadsForFragment

                                                                                                                                            fragmentSpreadsForFragment: (fragmentName: string) => FragmentSpreadNode[];

                                                                                                                                              method generateDecorations

                                                                                                                                              generateDecorations: () => void;

                                                                                                                                                method getOperationFieldsFromFieldDefinition

                                                                                                                                                getOperationFieldsFromFieldDefinition: (
                                                                                                                                                fieldName: string,
                                                                                                                                                parent: ObjectTypeDefinitionNode | null
                                                                                                                                                ) => FieldNode[];

                                                                                                                                                  method getProjectStats

                                                                                                                                                  getProjectStats: () => {
                                                                                                                                                  type: string;
                                                                                                                                                  serviceId: string | undefined;
                                                                                                                                                  types: { service: number; client: number; total: number };
                                                                                                                                                  tag: string;
                                                                                                                                                  loaded: boolean;
                                                                                                                                                  lastFetch: number | undefined;
                                                                                                                                                  };

                                                                                                                                                    method initialize

                                                                                                                                                    initialize: () => Promise<void>[];

                                                                                                                                                      method loadEngineData

                                                                                                                                                      loadEngineData: () => Promise<void>;

                                                                                                                                                        method onDecorations

                                                                                                                                                        onDecorations: (handler: (any: any) => void) => void;

                                                                                                                                                          method onSchemaTags

                                                                                                                                                          onSchemaTags: (handler: NotificationHandler<[string, string[]]>) => void;

                                                                                                                                                            method resolveSchema

                                                                                                                                                            resolveSchema: () => Promise<GraphQLSchema>;

                                                                                                                                                              method updateSchemaTag

                                                                                                                                                              updateSchemaTag: (tag: SchemaTag) => Promise<void>;

                                                                                                                                                                method validate

                                                                                                                                                                validate: () => Promise<void>;

                                                                                                                                                                  class GraphQLProject

                                                                                                                                                                  abstract class GraphQLProject implements GraphQLSchemaProvider {}

                                                                                                                                                                    constructor

                                                                                                                                                                    constructor({
                                                                                                                                                                    config,
                                                                                                                                                                    fileSet,
                                                                                                                                                                    loadingHandler,
                                                                                                                                                                    clientIdentity,
                                                                                                                                                                    }: GraphQLProjectConfig);

                                                                                                                                                                      property config

                                                                                                                                                                      config: ApolloConfig;

                                                                                                                                                                        property definitions

                                                                                                                                                                        readonly definitions: DefinitionNode[];

                                                                                                                                                                          property displayName

                                                                                                                                                                          readonly displayName: string;

                                                                                                                                                                            property documents

                                                                                                                                                                            readonly documents: GraphQLDocument[];

                                                                                                                                                                              property documentsByFile

                                                                                                                                                                              protected documentsByFile: Map<string, GraphQLDocument[]>;

                                                                                                                                                                                property engine

                                                                                                                                                                                readonly engine: ApolloEngineClient;

                                                                                                                                                                                  property engineClient

                                                                                                                                                                                  protected engineClient?: ApolloEngineClient;

                                                                                                                                                                                    property isReady

                                                                                                                                                                                    readonly isReady: boolean;

                                                                                                                                                                                      property lastLoadDate

                                                                                                                                                                                      protected lastLoadDate?: number;

                                                                                                                                                                                        property loadingHandler

                                                                                                                                                                                        protected loadingHandler: LoadingHandler;

                                                                                                                                                                                          property schema

                                                                                                                                                                                          schema?: GraphQLSchema;

                                                                                                                                                                                            property schemaProvider

                                                                                                                                                                                            schemaProvider: GraphQLSchemaProvider;

                                                                                                                                                                                              property typeSystemDefinitionsAndExtensions

                                                                                                                                                                                              readonly typeSystemDefinitionsAndExtensions: any[];

                                                                                                                                                                                                property whenReady

                                                                                                                                                                                                readonly whenReady: Promise<void>;

                                                                                                                                                                                                  method checkForDuplicateOperations

                                                                                                                                                                                                  checkForDuplicateOperations: () => void;

                                                                                                                                                                                                    method clearAllDiagnostics

                                                                                                                                                                                                    clearAllDiagnostics: () => void;

                                                                                                                                                                                                      method definitionsAt

                                                                                                                                                                                                      definitionsAt: (uri: DocumentUri) => DefinitionNode[];

                                                                                                                                                                                                        method documentAt

                                                                                                                                                                                                        documentAt: (
                                                                                                                                                                                                        uri: DocumentUri,
                                                                                                                                                                                                        position: Position
                                                                                                                                                                                                        ) => GraphQLDocument | undefined;

                                                                                                                                                                                                          method documentDidChange

                                                                                                                                                                                                          documentDidChange: (document: TextDocument) => void;

                                                                                                                                                                                                            method documentsAt

                                                                                                                                                                                                            documentsAt: (uri: DocumentUri) => GraphQLDocument[] | undefined;

                                                                                                                                                                                                              method fileDidChange

                                                                                                                                                                                                              fileDidChange: (uri: DocumentUri) => void;

                                                                                                                                                                                                                method fileWasDeleted

                                                                                                                                                                                                                fileWasDeleted: (uri: DocumentUri) => void;

                                                                                                                                                                                                                  method getProjectStats

                                                                                                                                                                                                                  abstract getProjectStats: () => ProjectStats;

                                                                                                                                                                                                                    method includesFile

                                                                                                                                                                                                                    includesFile: (uri: DocumentUri) => boolean;

                                                                                                                                                                                                                      method initialize

                                                                                                                                                                                                                      protected abstract initialize: () => Promise<void>[];

                                                                                                                                                                                                                        method invalidate

                                                                                                                                                                                                                        protected invalidate: () => void;

                                                                                                                                                                                                                          method onDiagnostics

                                                                                                                                                                                                                          onDiagnostics: (handler: NotificationHandler<PublishDiagnosticsParams>) => void;

                                                                                                                                                                                                                            method onSchemaChange

                                                                                                                                                                                                                            onSchemaChange: (
                                                                                                                                                                                                                            handler: NotificationHandler<GraphQLSchema>
                                                                                                                                                                                                                            ) => import('../providers/schema').SchemaChangeUnsubscribeHandler;

                                                                                                                                                                                                                              method resolveFederatedServiceSDL

                                                                                                                                                                                                                              resolveFederatedServiceSDL: () => Promise<string | void>;

                                                                                                                                                                                                                                method resolveSchema

                                                                                                                                                                                                                                resolveSchema: (config: SchemaResolveConfig) => Promise<GraphQLSchema>;

                                                                                                                                                                                                                                  method scanAllIncludedFiles

                                                                                                                                                                                                                                  scanAllIncludedFiles: () => Promise<void>;

                                                                                                                                                                                                                                    method updateConfig

                                                                                                                                                                                                                                    updateConfig: (config: ApolloConfig) => Promise<void>[];

                                                                                                                                                                                                                                      method validate

                                                                                                                                                                                                                                      abstract validate: () => void;

                                                                                                                                                                                                                                        class GraphQLServiceProject

                                                                                                                                                                                                                                        class GraphQLServiceProject extends GraphQLProject {}

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          constructor({
                                                                                                                                                                                                                                          clientIdentity,
                                                                                                                                                                                                                                          config,
                                                                                                                                                                                                                                          rootURI,
                                                                                                                                                                                                                                          loadingHandler,
                                                                                                                                                                                                                                          }: GraphQLServiceProjectConfig);

                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                            readonly displayName: string;

                                                                                                                                                                                                                                              method getProjectStats

                                                                                                                                                                                                                                              getProjectStats: () => { loaded: boolean; type: string };

                                                                                                                                                                                                                                                method initialize

                                                                                                                                                                                                                                                initialize: () => never[];

                                                                                                                                                                                                                                                  method resolveFederationInfo

                                                                                                                                                                                                                                                  resolveFederationInfo: () => Promise<string | void>;

                                                                                                                                                                                                                                                    method validate

                                                                                                                                                                                                                                                    validate: () => void;

                                                                                                                                                                                                                                                      class ServiceConfig

                                                                                                                                                                                                                                                      class ServiceConfig extends ApolloConfig {}

                                                                                                                                                                                                                                                        property service

                                                                                                                                                                                                                                                        service: ServiceConfigFormat;

                                                                                                                                                                                                                                                          class ToolError

                                                                                                                                                                                                                                                          class ToolError extends Error {}

                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                            constructor(message: string);

                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                interface ClientConfigFormat

                                                                                                                                                                                                                                                                interface ClientConfigFormat extends ConfigBase {}

                                                                                                                                                                                                                                                                  property addTypename

                                                                                                                                                                                                                                                                  addTypename?: boolean;

                                                                                                                                                                                                                                                                    property clientOnlyDirectives

                                                                                                                                                                                                                                                                    clientOnlyDirectives?: string[];

                                                                                                                                                                                                                                                                      property clientSchemaDirectives

                                                                                                                                                                                                                                                                      clientSchemaDirectives?: string[];

                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                        name?: ClientID;

                                                                                                                                                                                                                                                                          property referenceID

                                                                                                                                                                                                                                                                          referenceID?: string;

                                                                                                                                                                                                                                                                            property service

                                                                                                                                                                                                                                                                            service?: ServiceSpecifier | ClientServiceConfig;

                                                                                                                                                                                                                                                                              property statsWindow

                                                                                                                                                                                                                                                                              statsWindow?: EngineStatsWindow;

                                                                                                                                                                                                                                                                                property tagName

                                                                                                                                                                                                                                                                                tagName?: string;

                                                                                                                                                                                                                                                                                  property validationRules

                                                                                                                                                                                                                                                                                  validationRules?: ValidationRule[] | ((rule: ValidationRule) => boolean);

                                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                                    version?: string;

                                                                                                                                                                                                                                                                                      interface ClientIdentity

                                                                                                                                                                                                                                                                                      interface ClientIdentity {}

                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                        name?: string;

                                                                                                                                                                                                                                                                                          property referenceID

                                                                                                                                                                                                                                                                                          referenceID?: string;

                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                            version?: string;

                                                                                                                                                                                                                                                                                              interface ConfigBase

                                                                                                                                                                                                                                                                                              interface ConfigBase {}

                                                                                                                                                                                                                                                                                                property excludes

                                                                                                                                                                                                                                                                                                excludes: string[];

                                                                                                                                                                                                                                                                                                  property includes

                                                                                                                                                                                                                                                                                                  includes: string[];

                                                                                                                                                                                                                                                                                                    interface ConfigBaseFormat

                                                                                                                                                                                                                                                                                                    interface ConfigBaseFormat {}

                                                                                                                                                                                                                                                                                                      property client

                                                                                                                                                                                                                                                                                                      client?: ClientConfigFormat;

                                                                                                                                                                                                                                                                                                        property engine

                                                                                                                                                                                                                                                                                                        engine?: EngineConfig;

                                                                                                                                                                                                                                                                                                          property service

                                                                                                                                                                                                                                                                                                          service?: ServiceConfigFormat;

                                                                                                                                                                                                                                                                                                            interface EngineConfig

                                                                                                                                                                                                                                                                                                            interface EngineConfig {}

                                                                                                                                                                                                                                                                                                              property apiKey

                                                                                                                                                                                                                                                                                                              readonly apiKey?: string;

                                                                                                                                                                                                                                                                                                                property endpoint

                                                                                                                                                                                                                                                                                                                endpoint?: EndpointURI;

                                                                                                                                                                                                                                                                                                                  interface EngineStatsWindow

                                                                                                                                                                                                                                                                                                                  interface EngineStatsWindow {}

                                                                                                                                                                                                                                                                                                                    property from

                                                                                                                                                                                                                                                                                                                    from: number;

                                                                                                                                                                                                                                                                                                                      property to

                                                                                                                                                                                                                                                                                                                      to: number;

                                                                                                                                                                                                                                                                                                                        interface GraphQLSchemaProvider

                                                                                                                                                                                                                                                                                                                        interface GraphQLSchemaProvider {}

                                                                                                                                                                                                                                                                                                                          method onSchemaChange

                                                                                                                                                                                                                                                                                                                          onSchemaChange: (
                                                                                                                                                                                                                                                                                                                          handler: NotificationHandler<GraphQLSchema>
                                                                                                                                                                                                                                                                                                                          ) => SchemaChangeUnsubscribeHandler;

                                                                                                                                                                                                                                                                                                                            method resolveFederatedServiceSDL

                                                                                                                                                                                                                                                                                                                            resolveFederatedServiceSDL: () => Promise<string | void>;

                                                                                                                                                                                                                                                                                                                              method resolveSchema

                                                                                                                                                                                                                                                                                                                              resolveSchema: (config?: SchemaResolveConfig) => Promise<GraphQLSchema>;

                                                                                                                                                                                                                                                                                                                                interface HistoricalEngineStatsWindow

                                                                                                                                                                                                                                                                                                                                interface HistoricalEngineStatsWindow extends EngineStatsWindow {}

                                                                                                                                                                                                                                                                                                                                  interface LoadConfigSettings

                                                                                                                                                                                                                                                                                                                                  interface LoadConfigSettings {}

                                                                                                                                                                                                                                                                                                                                    property configFileName

                                                                                                                                                                                                                                                                                                                                    configFileName?: string;

                                                                                                                                                                                                                                                                                                                                      property configPath

                                                                                                                                                                                                                                                                                                                                      configPath?: string;

                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                        name?: string;

                                                                                                                                                                                                                                                                                                                                          property requireConfig

                                                                                                                                                                                                                                                                                                                                          requireConfig?: boolean;

                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                            type?: 'service' | 'client';

                                                                                                                                                                                                                                                                                                                                              interface LoadingHandler

                                                                                                                                                                                                                                                                                                                                              interface LoadingHandler {}

                                                                                                                                                                                                                                                                                                                                                method handle

                                                                                                                                                                                                                                                                                                                                                handle: <T>(message: string, value: Promise<T>) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                  method handleSync

                                                                                                                                                                                                                                                                                                                                                  handleSync: <T>(message: string, value: () => T) => T;

                                                                                                                                                                                                                                                                                                                                                    method showError

                                                                                                                                                                                                                                                                                                                                                    showError: (message: string) => void;

                                                                                                                                                                                                                                                                                                                                                      interface LocalServiceConfig

                                                                                                                                                                                                                                                                                                                                                      interface LocalServiceConfig {}

                                                                                                                                                                                                                                                                                                                                                        property localSchemaFile

                                                                                                                                                                                                                                                                                                                                                        localSchemaFile: string | string[];

                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                          name: ServiceID;

                                                                                                                                                                                                                                                                                                                                                            interface RemoteServiceConfig

                                                                                                                                                                                                                                                                                                                                                            interface RemoteServiceConfig {}

                                                                                                                                                                                                                                                                                                                                                              property headers

                                                                                                                                                                                                                                                                                                                                                              headers?: {
                                                                                                                                                                                                                                                                                                                                                              [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                name: ServiceID;

                                                                                                                                                                                                                                                                                                                                                                  property skipSSLValidation

                                                                                                                                                                                                                                                                                                                                                                  skipSSLValidation?: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                                                                                                                                    url: EndpointURI;

                                                                                                                                                                                                                                                                                                                                                                      interface ServiceConfigFormat

                                                                                                                                                                                                                                                                                                                                                                      interface ServiceConfigFormat extends ConfigBase {}

                                                                                                                                                                                                                                                                                                                                                                        property endpoint

                                                                                                                                                                                                                                                                                                                                                                        endpoint?: Exclude<RemoteServiceConfig, 'name'>;

                                                                                                                                                                                                                                                                                                                                                                          property localSchemaFile

                                                                                                                                                                                                                                                                                                                                                                          localSchemaFile?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                            name?: string;

                                                                                                                                                                                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                                                                                                                                                                                              type ApolloConfigFormat

                                                                                                                                                                                                                                                                                                                                                                              type ApolloConfigFormat =
                                                                                                                                                                                                                                                                                                                                                                              | WithRequired<ConfigBaseFormat, 'client'>
                                                                                                                                                                                                                                                                                                                                                                              | WithRequired<ConfigBaseFormat, 'service'>;

                                                                                                                                                                                                                                                                                                                                                                                type ClientID

                                                                                                                                                                                                                                                                                                                                                                                type ClientID = string;

                                                                                                                                                                                                                                                                                                                                                                                  type ClientServiceConfig

                                                                                                                                                                                                                                                                                                                                                                                  type ClientServiceConfig = RemoteServiceConfig | LocalServiceConfig;

                                                                                                                                                                                                                                                                                                                                                                                    type ConfigResult

                                                                                                                                                                                                                                                                                                                                                                                    type ConfigResult<T> = {
                                                                                                                                                                                                                                                                                                                                                                                    config: T;
                                                                                                                                                                                                                                                                                                                                                                                    filepath: string;
                                                                                                                                                                                                                                                                                                                                                                                    } | null;

                                                                                                                                                                                                                                                                                                                                                                                      type EndpointURI

                                                                                                                                                                                                                                                                                                                                                                                      type EndpointURI = string;

                                                                                                                                                                                                                                                                                                                                                                                        type FieldStats

                                                                                                                                                                                                                                                                                                                                                                                        type FieldStats = Map<string, Map<string, number | null>>;

                                                                                                                                                                                                                                                                                                                                                                                          type SchemaTag

                                                                                                                                                                                                                                                                                                                                                                                          type SchemaTag = string;

                                                                                                                                                                                                                                                                                                                                                                                            type ServiceID

                                                                                                                                                                                                                                                                                                                                                                                            type ServiceID = string;

                                                                                                                                                                                                                                                                                                                                                                                              type ServiceIDAndTag

                                                                                                                                                                                                                                                                                                                                                                                              type ServiceIDAndTag = [ServiceID, SchemaTag?];

                                                                                                                                                                                                                                                                                                                                                                                                type ServiceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                type ServiceSpecifier = string;

                                                                                                                                                                                                                                                                                                                                                                                                  Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                  namespace @apollographql/graphql-language-service-interface

                                                                                                                                                                                                                                                                                                                                                                                                  module '@apollographql/graphql-language-service-interface' {}

                                                                                                                                                                                                                                                                                                                                                                                                    function getAutocompleteSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                    getAutocompleteSuggestions: (
                                                                                                                                                                                                                                                                                                                                                                                                    schema: GraphQLSchema,
                                                                                                                                                                                                                                                                                                                                                                                                    queryText: string,
                                                                                                                                                                                                                                                                                                                                                                                                    position: Position
                                                                                                                                                                                                                                                                                                                                                                                                    ) => CompletionItem[];

                                                                                                                                                                                                                                                                                                                                                                                                      namespace @apollographql/graphql-language-service-interface/dist/getAutocompleteSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                      module '@apollographql/graphql-language-service-interface/dist/getAutocompleteSuggestions' {}

                                                                                                                                                                                                                                                                                                                                                                                                        namespace @apollographql/graphql-language-service-interface/dist/getDiagnostics

                                                                                                                                                                                                                                                                                                                                                                                                        module '@apollographql/graphql-language-service-interface/dist/getDiagnostics' {}

                                                                                                                                                                                                                                                                                                                                                                                                          function getRange

                                                                                                                                                                                                                                                                                                                                                                                                          getRange: (location: Location, queryText: string) => Range;

                                                                                                                                                                                                                                                                                                                                                                                                            namespace graphqlTypes

                                                                                                                                                                                                                                                                                                                                                                                                            module 'lib/graphqlTypes.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                              interface CheckPartialSchema

                                                                                                                                                                                                                                                                                                                                                                                                              interface CheckPartialSchema {}

                                                                                                                                                                                                                                                                                                                                                                                                                property service

                                                                                                                                                                                                                                                                                                                                                                                                                service: CheckPartialSchema_service | null;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service

                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property checkPartialSchema

                                                                                                                                                                                                                                                                                                                                                                                                                    checkPartialSchema: CheckPartialSchema_service_checkPartialSchema;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckPartialSchema_service_checkPartialSchema

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckPartialSchema_service_checkPartialSchema {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property checkSchemaResult

                                                                                                                                                                                                                                                                                                                                                                                                                        checkSchemaResult: CheckPartialSchema_service_checkPartialSchema_checkSchemaResult | null;

                                                                                                                                                                                                                                                                                                                                                                                                                          property compositionValidationResult

                                                                                                                                                                                                                                                                                                                                                                                                                          compositionValidationResult: CheckPartialSchema_service_checkPartialSchema_compositionValidationResult;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult

                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property diffToPrevious

                                                                                                                                                                                                                                                                                                                                                                                                                              diffToPrevious: CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious;

                                                                                                                                                                                                                                                                                                                                                                                                                                property targetUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                targetUrl: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property affectedClients

                                                                                                                                                                                                                                                                                                                                                                                                                                    affectedClients:
                                                                                                                                                                                                                                                                                                                                                                                                                                    | CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_affectedClients[]
                                                                                                                                                                                                                                                                                                                                                                                                                                    | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property affectedQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                      affectedQueries:
                                                                                                                                                                                                                                                                                                                                                                                                                                      | CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_affectedQueries[]
                                                                                                                                                                                                                                                                                                                                                                                                                                      | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property changes

                                                                                                                                                                                                                                                                                                                                                                                                                                        changes: CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_changes[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          property numberOfCheckedOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                          numberOfCheckedOperations: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                            severity: ChangeSeverity;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property validationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                              validationConfig: CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_validationConfig | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_affectedClients

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_affectedClients {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_affectedQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_affectedQueries {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_changes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                      code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                        description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                          severity: ChangeSeverity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_validationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckPartialSchema_service_checkPartialSchema_checkSchemaResult_diffToPrevious_validationConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                              from: any | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property queryCountThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                queryCountThreshold: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property queryCountThresholdPercentage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  queryCountThresholdPercentage: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    to: any | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckPartialSchema_service_checkPartialSchema_compositionValidationResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckPartialSchema_service_checkPartialSchema_compositionValidationResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property compositionValidationDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        compositionValidationDetails: CheckPartialSchema_service_checkPartialSchema_compositionValidationResult_compositionValidationDetails | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          errors: CheckPartialSchema_service_checkPartialSchema_compositionValidationResult_errors[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property graphCompositionID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            graphCompositionID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CheckPartialSchema_service_checkPartialSchema_compositionValidationResult_compositionValidationDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CheckPartialSchema_service_checkPartialSchema_compositionValidationResult_compositionValidationDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property schemaHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schemaHash: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service_checkPartialSchema_compositionValidationResult_errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckPartialSchema_service_checkPartialSchema_compositionValidationResult_errors {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckPartialSchemaVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckPartialSchemaVariables {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gitContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gitContext?: GitContextInput | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property graphVariant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          graphVariant: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property historicParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            historicParameters?: HistoricQueryParameters | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property implementingServiceName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                implementingServiceName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property partialSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  partialSchema: PartialSchemaInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CheckSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CheckSchema {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      service: CheckSchema_service | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CheckSchema_service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CheckSchema_service {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property checkSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          checkSchema: CheckSchema_service_checkSchema;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckSchema_service_checkSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckSchema_service_checkSchema {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property diffToPrevious

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diffToPrevious: CheckSchema_service_checkSchema_diffToPrevious;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property targetUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                targetUrl: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckSchema_service_checkSchema_diffToPrevious

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckSchema_service_checkSchema_diffToPrevious {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property affectedClients

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    affectedClients:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | CheckSchema_service_checkSchema_diffToPrevious_affectedClients[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property affectedQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      affectedQueries:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | CheckSchema_service_checkSchema_diffToPrevious_affectedQueries[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        changes: CheckSchema_service_checkSchema_diffToPrevious_changes[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property numberOfCheckedOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          numberOfCheckedOperations: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            severity: ChangeSeverity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property validationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              validationConfig: CheckSchema_service_checkSchema_diffToPrevious_validationConfig | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CheckSchema_service_checkSchema_diffToPrevious_affectedClients

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CheckSchema_service_checkSchema_diffToPrevious_affectedClients {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckSchema_service_checkSchema_diffToPrevious_affectedQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CheckSchema_service_checkSchema_diffToPrevious_affectedQueries {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CheckSchema_service_checkSchema_diffToPrevious_changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CheckSchema_service_checkSchema_diffToPrevious_changes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          severity: ChangeSeverity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckSchema_service_checkSchema_diffToPrevious_validationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CheckSchema_service_checkSchema_diffToPrevious_validationConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              from: any | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property queryCountThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                queryCountThreshold: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property queryCountThresholdPercentage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  queryCountThresholdPercentage: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    to: any | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckSchemaVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CheckSchemaVariables {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gitContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gitContext?: GitContextInput | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property historicParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          historicParameters?: HistoricQueryParameters | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              schema?: IntrospectionSchemaInput | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property schemaHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schemaHash?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClientInfoFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClientInfoFilter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property referenceID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        referenceID?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              service: GetSchemaByTag_service | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  schema: GetSchemaByTag_service_schema | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property directives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directives: GetSchemaByTag_service_schema___schema_directives[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mutationType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mutationType: GetSchemaByTag_service_schema___schema_mutationType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property queryType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queryType: GetSchemaByTag_service_schema___schema_queryType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property subscriptionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                subscriptionType: GetSchemaByTag_service_schema___schema_subscriptionType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  types: GetSchemaByTag_service_schema___schema_types[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_directives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_directives {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: GetSchemaByTag_service_schema___schema_directives_args[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property locations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          locations: IntrospectionDirectiveLocation[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_directives_args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_directives_args {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultValue: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: GetSchemaByTag_service_schema___schema_directives_args_type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_directives_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_mutationType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_mutationType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_queryType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_queryType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_subscriptionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_subscriptionType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enumValues: GetSchemaByTag_service_schema___schema_types_enumValues[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fields: GetSchemaByTag_service_schema___schema_types_fields[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inputFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inputFields: GetSchemaByTag_service_schema___schema_types_inputFields[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interfaces: GetSchemaByTag_service_schema___schema_types_interfaces[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property possibleTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  possibleTypes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | GetSchemaByTag_service_schema___schema_types_possibleTypes[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_enumValues {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property deprecationReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deprecationReason: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDeprecated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: GetSchemaByTag_service_schema___schema_types_fields_args[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deprecationReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deprecationReason: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDeprecated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: GetSchemaByTag_service_schema___schema_types_fields_type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_args {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaultValue: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: GetSchemaByTag_service_schema___schema_types_fields_args_type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ofType: GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSchemaByTag_service_schema___schema_types_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_fields_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_inputFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_inputFields {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultValue: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: GetSchemaByTag_service_schema___schema_types_inputFields_type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSchemaByTag_service_schema___schema_types_inputFields_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetSchemaByTag_service_schema___schema_types_interfaces_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetSchemaByTag_service_schema___schema_types_possibleTypes_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTagVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSchemaByTagVariables {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GitContextInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GitContextInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property branch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branch?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property commit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                commit?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property committer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  committer?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property remoteUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      remoteUrl?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HistoricQueryParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HistoricQueryParameters {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property excludedClients

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          excludedClients?: ClientInfoFilter[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property excludedOperationNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            excludedOperationNames?: OperationNameFilterInput[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              from?: any | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ignoredOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ignoredOperations?: string[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property includedVariants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includedVariants?: string[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property queryCountThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    queryCountThreshold?: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property queryCountThresholdPercentage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queryCountThresholdPercentage?: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        to?: any | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionDirectiveInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionDirectiveInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: IntrospectionInputValueInput[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              description?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isRepeatable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isRepeatable?: boolean | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property locations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  locations: IntrospectionDirectiveLocation[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IntrospectionEnumValueInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IntrospectionEnumValueInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property deprecationReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        deprecationReason?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          description?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDeprecated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IntrospectionFieldInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IntrospectionFieldInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  args: IntrospectionInputValueInput[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property deprecationReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deprecationReason?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDeprecated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: IntrospectionTypeInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IntrospectionFullType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IntrospectionFullType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enumValues: IntrospectionFullType_enumValues[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fields: IntrospectionFullType_fields[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inputFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inputFields: IntrospectionFullType_inputFields[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interfaces: IntrospectionFullType_interfaces[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property possibleTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              possibleTypes: IntrospectionFullType_possibleTypes[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IntrospectionFullType_enumValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IntrospectionFullType_enumValues {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deprecationReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deprecationReason: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDeprecated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: IntrospectionFullType_fields_args[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property deprecationReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deprecationReason: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDeprecated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: IntrospectionFullType_fields_type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IntrospectionFullType_fields_args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IntrospectionFullType_fields_args {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultValue: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            description: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: IntrospectionFullType_fields_args_type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: IntrospectionFullType_fields_args_type_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: IntrospectionFullType_fields_args_type_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: IntrospectionFullType_fields_args_type_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ofType: IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ofType: IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IntrospectionFullType_fields_args_type_ofType_ofType_ofType_ofType_ofType_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IntrospectionFullType_fields_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IntrospectionFullType_fields_type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ofType: IntrospectionFullType_fields_type_ofType | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IntrospectionFullType_fields_type_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IntrospectionFullType_fields_type_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ofType: IntrospectionFullType_fields_type_ofType_ofType | null;