apollo-language-server

  • Version 1.26.3
  • Published
  • 985 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: any,
                    document: any,
                    fragments?: { [fragmentName: string]: any },
                    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;

                                          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: any) => 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: any;

                                                                                                                      property config

                                                                                                                      config: ClientConfig;

                                                                                                                        property diagnosticSet

                                                                                                                        diagnosticSet?: DiagnosticSet;

                                                                                                                          property displayName

                                                                                                                          readonly displayName: string;

                                                                                                                            property fragments

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

                                                                                                                              property mergedOperationsAndFragments

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

                                                                                                                                property mergedOperationsAndFragmentsForService

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

                                                                                                                                  property missingApolloClientDirectives

                                                                                                                                  readonly missingApolloClientDirectives: readonly any[];

                                                                                                                                    property operations

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

                                                                                                                                      property rootURI

                                                                                                                                      rootURI: any;

                                                                                                                                        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: any) => 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: any[];

                                                                                                                                                                        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?: any;

                                                                                                                                                                                          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: any) => GraphQLDocument | undefined;

                                                                                                                                                                                                        method documentDidChange

                                                                                                                                                                                                        documentDidChange: (document: any) => 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: any) => void;

                                                                                                                                                                                                                          method onSchemaChange

                                                                                                                                                                                                                          onSchemaChange: (
                                                                                                                                                                                                                          handler: any
                                                                                                                                                                                                                          ) => 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: any) => 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: any,
                                                                                                                                                                                                                                                                                                                                                                                                  queryText: string,
                                                                                                                                                                                                                                                                                                                                                                                                  position: any
                                                                                                                                                                                                                                                                                                                                                                                                  ) => 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: any, queryText: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                          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 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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IntrospectionFullType_fields_type_ofType_ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IntrospectionFullType_fields_type_ofType_ofType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: IntrospectionTypeKind | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ofType: IntrospectionFullType_fields_type_ofType_ofType_ofType | null;