apollo-language-server

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

client?: ClientConfigFormat;

readonly configDirURI: any;

configURI?: any;

engine: EngineConfig;

graph: string;

isClient: boolean;

isService: boolean;

readonly projects: (ClientConfig | ServiceConfig)[];

rawConfig: any;

service?: ServiceConfigFormat;

variant: string;

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

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

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

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

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

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

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

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

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

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

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

willSendRequest: (request: any) => void;

client: ClientConfigFormat;

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

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

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

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

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

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

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

readonly clientSchema: DocumentNode;

config: ClientConfig;

diagnosticSet?: DiagnosticSet;

readonly displayName: string;

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

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

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

readonly missingApolloClientDirectives: readonly DefinitionNode[];

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

rootURI: URI;

serviceID?: string;

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

generateDecorations: () => void;

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

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

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

loadEngineData: () => Promise<void>;

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

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

resolveSchema: () => Promise<GraphQLSchema>;

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

validate: () => Promise<void>;

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

config: ApolloConfig;

readonly definitions: DefinitionNode[];

readonly displayName: string;

readonly documents: GraphQLDocument[];

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

readonly engine: ApolloEngineClient;

protected engineClient?: ApolloEngineClient;

readonly isReady: boolean;

protected lastLoadDate?: number;

protected loadingHandler: LoadingHandler;

schema?: GraphQLSchema;

schemaProvider: GraphQLSchemaProvider;

readonly typeSystemDefinitionsAndExtensions: any[];

readonly whenReady: Promise<void>;

checkForDuplicateOperations: () => void;

clearAllDiagnostics: () => void;

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

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

documentDidChange: (document: TextDocument) => void;

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

fileDidChange: (uri: DocumentUri) => void;

fileWasDeleted: (uri: DocumentUri) => void;

abstract getProjectStats: () => ProjectStats;

includesFile: (uri: DocumentUri) => boolean;

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

protected invalidate: () => void;

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

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

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

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

scanAllIncludedFiles: () => Promise<void>;

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

abstract validate: () => void;

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

readonly displayName: string;

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

initialize: () => never[];

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

validate: () => void;

service: ServiceConfigFormat;

constructor(message: string);

name: string;

addTypename?: boolean;

clientOnlyDirectives?: string[];

clientSchemaDirectives?: string[];

name?: ClientID;

referenceID?: string;

service?: ServiceSpecifier | ClientServiceConfig;

statsWindow?: EngineStatsWindow;

tagName?: string;

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

version?: string;

name?: string;

referenceID?: string;

version?: string;

excludes: string[];

includes: string[];

client?: ClientConfigFormat;

engine?: EngineConfig;

service?: ServiceConfigFormat;

readonly apiKey?: string;

endpoint?: EndpointURI;

from: number;

to: number;

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

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

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

configFileName?: string;

configPath?: string;

name?: string;

requireConfig?: boolean;

type?: 'service' | 'client';

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

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

showError: (message: string) => void;

localSchemaFile: string | string[];

name: ServiceID;

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

name: ServiceID;

skipSSLValidation?: boolean;

url: EndpointURI;

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

localSchemaFile?: string | string[];

name?: string;

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

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