1 | import { Source } from './source';
|
2 | import { TokenKindEnum } from './tokenKind';
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 | export class Location {
|
9 | |
10 |
|
11 |
|
12 | readonly start: number;
|
13 |
|
14 | |
15 |
|
16 |
|
17 | readonly end: number;
|
18 |
|
19 | |
20 |
|
21 |
|
22 | readonly startToken: Token;
|
23 |
|
24 | |
25 |
|
26 |
|
27 | readonly endToken: Token;
|
28 |
|
29 | |
30 |
|
31 |
|
32 | readonly source: Source;
|
33 |
|
34 | constructor(startToken: Token, endToken: Token, source: Source);
|
35 |
|
36 | toJSON(): { start: number; end: number };
|
37 | }
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 | export class Token {
|
44 | |
45 |
|
46 |
|
47 | readonly kind: TokenKindEnum;
|
48 |
|
49 | |
50 |
|
51 |
|
52 | readonly start: number;
|
53 |
|
54 | |
55 |
|
56 |
|
57 | readonly end: number;
|
58 |
|
59 | |
60 |
|
61 |
|
62 | readonly line: number;
|
63 |
|
64 | |
65 |
|
66 |
|
67 | readonly column: number;
|
68 |
|
69 | |
70 |
|
71 |
|
72 | readonly value: string | undefined;
|
73 |
|
74 | |
75 |
|
76 |
|
77 |
|
78 |
|
79 | readonly prev: Token | null;
|
80 | readonly next: Token | null;
|
81 |
|
82 | constructor(
|
83 | kind: TokenKindEnum,
|
84 | start: number,
|
85 | end: number,
|
86 | line: number,
|
87 | column: number,
|
88 | prev: Token | null,
|
89 | value?: string,
|
90 | );
|
91 |
|
92 | toJSON(): {
|
93 | kind: TokenKindEnum;
|
94 | value: string | undefined;
|
95 | line: number;
|
96 | column: number;
|
97 | };
|
98 | }
|
99 |
|
100 |
|
101 |
|
102 |
|
103 | export function isNode(maybeNode: any): maybeNode is ASTNode;
|
104 |
|
105 |
|
106 |
|
107 |
|
108 | export type ASTNode =
|
109 | | NameNode
|
110 | | DocumentNode
|
111 | | OperationDefinitionNode
|
112 | | VariableDefinitionNode
|
113 | | VariableNode
|
114 | | SelectionSetNode
|
115 | | FieldNode
|
116 | | ArgumentNode
|
117 | | FragmentSpreadNode
|
118 | | InlineFragmentNode
|
119 | | FragmentDefinitionNode
|
120 | | IntValueNode
|
121 | | FloatValueNode
|
122 | | StringValueNode
|
123 | | BooleanValueNode
|
124 | | NullValueNode
|
125 | | EnumValueNode
|
126 | | ListValueNode
|
127 | | ObjectValueNode
|
128 | | ObjectFieldNode
|
129 | | DirectiveNode
|
130 | | NamedTypeNode
|
131 | | ListTypeNode
|
132 | | NonNullTypeNode
|
133 | | SchemaDefinitionNode
|
134 | | OperationTypeDefinitionNode
|
135 | | ScalarTypeDefinitionNode
|
136 | | ObjectTypeDefinitionNode
|
137 | | FieldDefinitionNode
|
138 | | InputValueDefinitionNode
|
139 | | InterfaceTypeDefinitionNode
|
140 | | UnionTypeDefinitionNode
|
141 | | EnumTypeDefinitionNode
|
142 | | EnumValueDefinitionNode
|
143 | | InputObjectTypeDefinitionNode
|
144 | | DirectiveDefinitionNode
|
145 | | SchemaExtensionNode
|
146 | | ScalarTypeExtensionNode
|
147 | | ObjectTypeExtensionNode
|
148 | | InterfaceTypeExtensionNode
|
149 | | UnionTypeExtensionNode
|
150 | | EnumTypeExtensionNode
|
151 | | InputObjectTypeExtensionNode;
|
152 |
|
153 |
|
154 |
|
155 |
|
156 | export interface ASTKindToNode {
|
157 | Name: NameNode;
|
158 | Document: DocumentNode;
|
159 | OperationDefinition: OperationDefinitionNode;
|
160 | VariableDefinition: VariableDefinitionNode;
|
161 | Variable: VariableNode;
|
162 | SelectionSet: SelectionSetNode;
|
163 | Field: FieldNode;
|
164 | Argument: ArgumentNode;
|
165 | FragmentSpread: FragmentSpreadNode;
|
166 | InlineFragment: InlineFragmentNode;
|
167 | FragmentDefinition: FragmentDefinitionNode;
|
168 | IntValue: IntValueNode;
|
169 | FloatValue: FloatValueNode;
|
170 | StringValue: StringValueNode;
|
171 | BooleanValue: BooleanValueNode;
|
172 | NullValue: NullValueNode;
|
173 | EnumValue: EnumValueNode;
|
174 | ListValue: ListValueNode;
|
175 | ObjectValue: ObjectValueNode;
|
176 | ObjectField: ObjectFieldNode;
|
177 | Directive: DirectiveNode;
|
178 | NamedType: NamedTypeNode;
|
179 | ListType: ListTypeNode;
|
180 | NonNullType: NonNullTypeNode;
|
181 | SchemaDefinition: SchemaDefinitionNode;
|
182 | OperationTypeDefinition: OperationTypeDefinitionNode;
|
183 | ScalarTypeDefinition: ScalarTypeDefinitionNode;
|
184 | ObjectTypeDefinition: ObjectTypeDefinitionNode;
|
185 | FieldDefinition: FieldDefinitionNode;
|
186 | InputValueDefinition: InputValueDefinitionNode;
|
187 | InterfaceTypeDefinition: InterfaceTypeDefinitionNode;
|
188 | UnionTypeDefinition: UnionTypeDefinitionNode;
|
189 | EnumTypeDefinition: EnumTypeDefinitionNode;
|
190 | EnumValueDefinition: EnumValueDefinitionNode;
|
191 | InputObjectTypeDefinition: InputObjectTypeDefinitionNode;
|
192 | DirectiveDefinition: DirectiveDefinitionNode;
|
193 | SchemaExtension: SchemaExtensionNode;
|
194 | ScalarTypeExtension: ScalarTypeExtensionNode;
|
195 | ObjectTypeExtension: ObjectTypeExtensionNode;
|
196 | InterfaceTypeExtension: InterfaceTypeExtensionNode;
|
197 | UnionTypeExtension: UnionTypeExtensionNode;
|
198 | EnumTypeExtension: EnumTypeExtensionNode;
|
199 | InputObjectTypeExtension: InputObjectTypeExtensionNode;
|
200 | }
|
201 |
|
202 |
|
203 |
|
204 | export interface NameNode {
|
205 | readonly kind: 'Name';
|
206 | readonly loc?: Location;
|
207 | readonly value: string;
|
208 | }
|
209 |
|
210 |
|
211 |
|
212 | export interface DocumentNode {
|
213 | readonly kind: 'Document';
|
214 | readonly loc?: Location;
|
215 | readonly definitions: ReadonlyArray<DefinitionNode>;
|
216 | }
|
217 |
|
218 | export type DefinitionNode =
|
219 | | ExecutableDefinitionNode
|
220 | | TypeSystemDefinitionNode
|
221 | | TypeSystemExtensionNode;
|
222 |
|
223 | export type ExecutableDefinitionNode =
|
224 | | OperationDefinitionNode
|
225 | | FragmentDefinitionNode;
|
226 |
|
227 | export interface OperationDefinitionNode {
|
228 | readonly kind: 'OperationDefinition';
|
229 | readonly loc?: Location;
|
230 | readonly operation: OperationTypeNode;
|
231 | readonly name?: NameNode;
|
232 | readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
|
233 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
234 | readonly selectionSet: SelectionSetNode;
|
235 | }
|
236 |
|
237 | export type OperationTypeNode = 'query' | 'mutation' | 'subscription';
|
238 |
|
239 | export interface VariableDefinitionNode {
|
240 | readonly kind: 'VariableDefinition';
|
241 | readonly loc?: Location;
|
242 | readonly variable: VariableNode;
|
243 | readonly type: TypeNode;
|
244 | readonly defaultValue?: ValueNode;
|
245 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
246 | }
|
247 |
|
248 | export interface VariableNode {
|
249 | readonly kind: 'Variable';
|
250 | readonly loc?: Location;
|
251 | readonly name: NameNode;
|
252 | }
|
253 |
|
254 | export interface SelectionSetNode {
|
255 | kind: 'SelectionSet';
|
256 | loc?: Location;
|
257 | selections: ReadonlyArray<SelectionNode>;
|
258 | }
|
259 |
|
260 | export type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
|
261 |
|
262 | export interface FieldNode {
|
263 | readonly kind: 'Field';
|
264 | readonly loc?: Location;
|
265 | readonly alias?: NameNode;
|
266 | readonly name: NameNode;
|
267 | readonly arguments?: ReadonlyArray<ArgumentNode>;
|
268 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
269 | readonly selectionSet?: SelectionSetNode;
|
270 | }
|
271 |
|
272 | export interface ArgumentNode {
|
273 | readonly kind: 'Argument';
|
274 | readonly loc?: Location;
|
275 | readonly name: NameNode;
|
276 | readonly value: ValueNode;
|
277 | }
|
278 |
|
279 |
|
280 |
|
281 | export interface FragmentSpreadNode {
|
282 | readonly kind: 'FragmentSpread';
|
283 | readonly loc?: Location;
|
284 | readonly name: NameNode;
|
285 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
286 | }
|
287 |
|
288 | export interface InlineFragmentNode {
|
289 | readonly kind: 'InlineFragment';
|
290 | readonly loc?: Location;
|
291 | readonly typeCondition?: NamedTypeNode;
|
292 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
293 | readonly selectionSet: SelectionSetNode;
|
294 | }
|
295 |
|
296 | export interface FragmentDefinitionNode {
|
297 | readonly kind: 'FragmentDefinition';
|
298 | readonly loc?: Location;
|
299 | readonly name: NameNode;
|
300 |
|
301 |
|
302 | readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
|
303 | readonly typeCondition: NamedTypeNode;
|
304 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
305 | readonly selectionSet: SelectionSetNode;
|
306 | }
|
307 |
|
308 |
|
309 |
|
310 | export type ValueNode =
|
311 | | VariableNode
|
312 | | IntValueNode
|
313 | | FloatValueNode
|
314 | | StringValueNode
|
315 | | BooleanValueNode
|
316 | | NullValueNode
|
317 | | EnumValueNode
|
318 | | ListValueNode
|
319 | | ObjectValueNode;
|
320 |
|
321 | export interface IntValueNode {
|
322 | readonly kind: 'IntValue';
|
323 | readonly loc?: Location;
|
324 | readonly value: string;
|
325 | }
|
326 |
|
327 | export interface FloatValueNode {
|
328 | readonly kind: 'FloatValue';
|
329 | readonly loc?: Location;
|
330 | readonly value: string;
|
331 | }
|
332 |
|
333 | export interface StringValueNode {
|
334 | readonly kind: 'StringValue';
|
335 | readonly loc?: Location;
|
336 | readonly value: string;
|
337 | readonly block?: boolean;
|
338 | }
|
339 |
|
340 | export interface BooleanValueNode {
|
341 | readonly kind: 'BooleanValue';
|
342 | readonly loc?: Location;
|
343 | readonly value: boolean;
|
344 | }
|
345 |
|
346 | export interface NullValueNode {
|
347 | readonly kind: 'NullValue';
|
348 | readonly loc?: Location;
|
349 | }
|
350 |
|
351 | export interface EnumValueNode {
|
352 | readonly kind: 'EnumValue';
|
353 | readonly loc?: Location;
|
354 | readonly value: string;
|
355 | }
|
356 |
|
357 | export interface ListValueNode {
|
358 | readonly kind: 'ListValue';
|
359 | readonly loc?: Location;
|
360 | readonly values: ReadonlyArray<ValueNode>;
|
361 | }
|
362 |
|
363 | export interface ObjectValueNode {
|
364 | readonly kind: 'ObjectValue';
|
365 | readonly loc?: Location;
|
366 | readonly fields: ReadonlyArray<ObjectFieldNode>;
|
367 | }
|
368 |
|
369 | export interface ObjectFieldNode {
|
370 | readonly kind: 'ObjectField';
|
371 | readonly loc?: Location;
|
372 | readonly name: NameNode;
|
373 | readonly value: ValueNode;
|
374 | }
|
375 |
|
376 |
|
377 |
|
378 | export interface DirectiveNode {
|
379 | readonly kind: 'Directive';
|
380 | readonly loc?: Location;
|
381 | readonly name: NameNode;
|
382 | readonly arguments?: ReadonlyArray<ArgumentNode>;
|
383 | }
|
384 |
|
385 |
|
386 |
|
387 | export type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
|
388 |
|
389 | export interface NamedTypeNode {
|
390 | readonly kind: 'NamedType';
|
391 | readonly loc?: Location;
|
392 | readonly name: NameNode;
|
393 | }
|
394 |
|
395 | export interface ListTypeNode {
|
396 | readonly kind: 'ListType';
|
397 | readonly loc?: Location;
|
398 | readonly type: TypeNode;
|
399 | }
|
400 |
|
401 | export interface NonNullTypeNode {
|
402 | readonly kind: 'NonNullType';
|
403 | readonly loc?: Location;
|
404 | readonly type: NamedTypeNode | ListTypeNode;
|
405 | }
|
406 |
|
407 |
|
408 |
|
409 | export type TypeSystemDefinitionNode =
|
410 | | SchemaDefinitionNode
|
411 | | TypeDefinitionNode
|
412 | | DirectiveDefinitionNode;
|
413 |
|
414 | export interface SchemaDefinitionNode {
|
415 | readonly kind: 'SchemaDefinition';
|
416 | readonly loc?: Location;
|
417 | readonly description?: StringValueNode;
|
418 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
419 | readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
|
420 | }
|
421 |
|
422 | export interface OperationTypeDefinitionNode {
|
423 | readonly kind: 'OperationTypeDefinition';
|
424 | readonly loc?: Location;
|
425 | readonly operation: OperationTypeNode;
|
426 | readonly type: NamedTypeNode;
|
427 | }
|
428 |
|
429 |
|
430 |
|
431 | export type TypeDefinitionNode =
|
432 | | ScalarTypeDefinitionNode
|
433 | | ObjectTypeDefinitionNode
|
434 | | InterfaceTypeDefinitionNode
|
435 | | UnionTypeDefinitionNode
|
436 | | EnumTypeDefinitionNode
|
437 | | InputObjectTypeDefinitionNode;
|
438 |
|
439 | export interface ScalarTypeDefinitionNode {
|
440 | readonly kind: 'ScalarTypeDefinition';
|
441 | readonly loc?: Location;
|
442 | readonly description?: StringValueNode;
|
443 | readonly name: NameNode;
|
444 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
445 | }
|
446 |
|
447 | export interface ObjectTypeDefinitionNode {
|
448 | readonly kind: 'ObjectTypeDefinition';
|
449 | readonly loc?: Location;
|
450 | readonly description?: StringValueNode;
|
451 | readonly name: NameNode;
|
452 | readonly interfaces?: ReadonlyArray<NamedTypeNode>;
|
453 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
454 | readonly fields?: ReadonlyArray<FieldDefinitionNode>;
|
455 | }
|
456 |
|
457 | export interface FieldDefinitionNode {
|
458 | readonly kind: 'FieldDefinition';
|
459 | readonly loc?: Location;
|
460 | readonly description?: StringValueNode;
|
461 | readonly name: NameNode;
|
462 | readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
|
463 | readonly type: TypeNode;
|
464 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
465 | }
|
466 |
|
467 | export interface InputValueDefinitionNode {
|
468 | readonly kind: 'InputValueDefinition';
|
469 | readonly loc?: Location;
|
470 | readonly description?: StringValueNode;
|
471 | readonly name: NameNode;
|
472 | readonly type: TypeNode;
|
473 | readonly defaultValue?: ValueNode;
|
474 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
475 | }
|
476 |
|
477 | export interface InterfaceTypeDefinitionNode {
|
478 | readonly kind: 'InterfaceTypeDefinition';
|
479 | readonly loc?: Location;
|
480 | readonly description?: StringValueNode;
|
481 | readonly name: NameNode;
|
482 | readonly interfaces?: ReadonlyArray<NamedTypeNode>;
|
483 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
484 | readonly fields?: ReadonlyArray<FieldDefinitionNode>;
|
485 | }
|
486 |
|
487 | export interface UnionTypeDefinitionNode {
|
488 | readonly kind: 'UnionTypeDefinition';
|
489 | readonly loc?: Location;
|
490 | readonly description?: StringValueNode;
|
491 | readonly name: NameNode;
|
492 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
493 | readonly types?: ReadonlyArray<NamedTypeNode>;
|
494 | }
|
495 |
|
496 | export interface EnumTypeDefinitionNode {
|
497 | readonly kind: 'EnumTypeDefinition';
|
498 | readonly loc?: Location;
|
499 | readonly description?: StringValueNode;
|
500 | readonly name: NameNode;
|
501 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
502 | readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
|
503 | }
|
504 |
|
505 | export interface EnumValueDefinitionNode {
|
506 | readonly kind: 'EnumValueDefinition';
|
507 | readonly loc?: Location;
|
508 | readonly description?: StringValueNode;
|
509 | readonly name: NameNode;
|
510 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
511 | }
|
512 |
|
513 | export interface InputObjectTypeDefinitionNode {
|
514 | readonly kind: 'InputObjectTypeDefinition';
|
515 | readonly loc?: Location;
|
516 | readonly description?: StringValueNode;
|
517 | readonly name: NameNode;
|
518 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
519 | readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
|
520 | }
|
521 |
|
522 |
|
523 |
|
524 | export interface DirectiveDefinitionNode {
|
525 | readonly kind: 'DirectiveDefinition';
|
526 | readonly loc?: Location;
|
527 | readonly description?: StringValueNode;
|
528 | readonly name: NameNode;
|
529 | readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
|
530 | readonly repeatable: boolean;
|
531 | readonly locations: ReadonlyArray<NameNode>;
|
532 | }
|
533 |
|
534 |
|
535 |
|
536 | export type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;
|
537 |
|
538 | export interface SchemaExtensionNode {
|
539 | readonly kind: 'SchemaExtension';
|
540 | readonly loc?: Location;
|
541 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
542 | readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
|
543 | }
|
544 |
|
545 |
|
546 |
|
547 | export type TypeExtensionNode =
|
548 | | ScalarTypeExtensionNode
|
549 | | ObjectTypeExtensionNode
|
550 | | InterfaceTypeExtensionNode
|
551 | | UnionTypeExtensionNode
|
552 | | EnumTypeExtensionNode
|
553 | | InputObjectTypeExtensionNode;
|
554 |
|
555 | export interface ScalarTypeExtensionNode {
|
556 | readonly kind: 'ScalarTypeExtension';
|
557 | readonly loc?: Location;
|
558 | readonly name: NameNode;
|
559 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
560 | }
|
561 |
|
562 | export interface ObjectTypeExtensionNode {
|
563 | readonly kind: 'ObjectTypeExtension';
|
564 | readonly loc?: Location;
|
565 | readonly name: NameNode;
|
566 | readonly interfaces?: ReadonlyArray<NamedTypeNode>;
|
567 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
568 | readonly fields?: ReadonlyArray<FieldDefinitionNode>;
|
569 | }
|
570 |
|
571 | export interface InterfaceTypeExtensionNode {
|
572 | readonly kind: 'InterfaceTypeExtension';
|
573 | readonly loc?: Location;
|
574 | readonly name: NameNode;
|
575 | readonly interfaces?: ReadonlyArray<NamedTypeNode>;
|
576 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
577 | readonly fields?: ReadonlyArray<FieldDefinitionNode>;
|
578 | }
|
579 |
|
580 | export interface UnionTypeExtensionNode {
|
581 | readonly kind: 'UnionTypeExtension';
|
582 | readonly loc?: Location;
|
583 | readonly name: NameNode;
|
584 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
585 | readonly types?: ReadonlyArray<NamedTypeNode>;
|
586 | }
|
587 |
|
588 | export interface EnumTypeExtensionNode {
|
589 | readonly kind: 'EnumTypeExtension';
|
590 | readonly loc?: Location;
|
591 | readonly name: NameNode;
|
592 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
593 | readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
|
594 | }
|
595 |
|
596 | export interface InputObjectTypeExtensionNode {
|
597 | readonly kind: 'InputObjectTypeExtension';
|
598 | readonly loc?: Location;
|
599 | readonly name: NameNode;
|
600 | readonly directives?: ReadonlyArray<DirectiveNode>;
|
601 | readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
|
602 | }
|