graphql-language-service-parser

const AdditionalRuleKinds: _AdditionalRuleKinds;

const LexRules: {
    Name: RegExp;
    Punctuation: RegExp;
    Number: RegExp;
    String: RegExp;
    Comment: RegExp;
};

const ParseRules: { [name: string]: ParseRule };

const RuleKinds: {
    ALIASED_FIELD: 'AliasedField';
    ARGUMENTS: 'Arguments';
    SHORT_QUERY: 'ShortQuery';
    QUERY: 'Query';
    MUTATION: 'Mutation';
    SUBSCRIPTION: 'Subscription';
    TYPE_CONDITION: 'TypeCondition';
    INVALID: 'Invalid';
    COMMENT: 'Comment';
    SCHEMA_DEF: 'SchemaDef';
    SCALAR_DEF: 'ScalarDef';
    OBJECT_TYPE_DEF: 'ObjectTypeDef';
    OBJECT_VALUE: 'ObjectValue';
    LIST_VALUE: 'ListValue';
    INTERFACE_DEF: 'InterfaceDef';
    UNION_DEF: 'UnionDef';
    ENUM_DEF: 'EnumDef';
    ENUM_VALUE: 'EnumValue';
    FIELD_DEF: 'FieldDef';
    INPUT_DEF: 'InputDef';
    INPUT_VALUE_DEF: 'InputValueDef';
    ARGUMENTS_DEF: 'ArgumentsDef';
    EXTEND_DEF: 'ExtendDef';
    DIRECTIVE_DEF: 'DirectiveDef';
    IMPLEMENTS: 'Implements';
    VARIABLE_DEFINITIONS: 'VariableDefinitions';
    TYPE: 'Type';
    NAME: Kind.NAME;
    DOCUMENT: Kind.DOCUMENT;
    OPERATION_DEFINITION: Kind.OPERATION_DEFINITION;
    VARIABLE_DEFINITION: Kind.VARIABLE_DEFINITION;
    SELECTION_SET: Kind.SELECTION_SET;
    FIELD: Kind.FIELD;
    ARGUMENT: Kind.ARGUMENT;
    FRAGMENT_SPREAD: Kind.FRAGMENT_SPREAD;
    INLINE_FRAGMENT: Kind.INLINE_FRAGMENT;
    FRAGMENT_DEFINITION: Kind.FRAGMENT_DEFINITION;
    VARIABLE: Kind.VARIABLE;
    INT: Kind.INT;
    FLOAT: Kind.FLOAT;
    STRING: Kind.STRING;
    BOOLEAN: Kind.BOOLEAN;
    NULL: Kind.NULL;
    ENUM: Kind.ENUM;
    LIST: Kind.LIST;
    OBJECT: Kind.OBJECT;
    OBJECT_FIELD: Kind.OBJECT_FIELD;
    DIRECTIVE: Kind.DIRECTIVE;
    NAMED_TYPE: Kind.NAMED_TYPE;
    LIST_TYPE: Kind.LIST_TYPE;
    NON_NULL_TYPE: Kind.NON_NULL_TYPE;
    SCHEMA_DEFINITION: Kind.SCHEMA_DEFINITION;
    OPERATION_TYPE_DEFINITION: Kind.OPERATION_TYPE_DEFINITION;
    SCALAR_TYPE_DEFINITION: Kind.SCALAR_TYPE_DEFINITION;
    OBJECT_TYPE_DEFINITION: Kind.OBJECT_TYPE_DEFINITION;
    FIELD_DEFINITION: Kind.FIELD_DEFINITION;
    INPUT_VALUE_DEFINITION: Kind.INPUT_VALUE_DEFINITION;
    INTERFACE_TYPE_DEFINITION: Kind.INTERFACE_TYPE_DEFINITION;
    UNION_TYPE_DEFINITION: Kind.UNION_TYPE_DEFINITION;
    ENUM_TYPE_DEFINITION: Kind.ENUM_TYPE_DEFINITION;
    ENUM_VALUE_DEFINITION: Kind.ENUM_VALUE_DEFINITION;
    INPUT_OBJECT_TYPE_DEFINITION: Kind.INPUT_OBJECT_TYPE_DEFINITION;
    DIRECTIVE_DEFINITION: Kind.DIRECTIVE_DEFINITION;
    SCHEMA_EXTENSION: Kind.SCHEMA_EXTENSION;
    SCALAR_TYPE_EXTENSION: Kind.SCALAR_TYPE_EXTENSION;
    OBJECT_TYPE_EXTENSION: Kind.OBJECT_TYPE_EXTENSION;
    INTERFACE_TYPE_EXTENSION: Kind.INTERFACE_TYPE_EXTENSION;
    UNION_TYPE_EXTENSION: Kind.UNION_TYPE_EXTENSION;
    ENUM_TYPE_EXTENSION: Kind.ENUM_TYPE_EXTENSION;
    INPUT_OBJECT_TYPE_EXTENSION: Kind.INPUT_OBJECT_TYPE_EXTENSION;
};

butNot: (rule: Rule, exclusions: Array<Rule>) => Rule;

isIgnored: (ch: string) => boolean;

list: (ofRule: Rule | string, separator?: string | Rule) => Rule;

onlineParser: (options?: ParserOptions) => {
    startState: () => State;
    token: (stream: CharacterStream, state: State) => string;
};

opt: (ofRule: Rule | string) => Rule;

p: (value: string, style?: string) => Rule;

t: (
    kind: string,
    style: string
) => { style: string; match: (token: Token) => boolean };

type ContextToken = {
    start: number;
    end: number;
    string: string;
    state: State;
    style?: string;
};

type ContextTokenForCodeMirror = {
    start: number;
    end: number;
    string: string;
    type: string | null;
    state: State;
};

type ContextTokenUnion = ContextToken | ContextTokenForCodeMirror;

type ParserOptions = {
    eatWhitespace: (stream: CharacterStream) => boolean;
    lexRules: Partial<typeof LexRulesType>;
    parseRules: typeof ParseRulesType;
    editorConfig: {
        [name: string]: any;
    };
};

type ParseRule =
    | RuleOrString[]
    | ((token: Token, stream: CharacterStream) => string | null | void);

type Rule = {
    style?: string;
    match?: (token: Token) => boolean;
    update?: (state: State, token: Token) => void;
    separator?: string | Rule;
    isList?: boolean;
    ofRule?: Rule | string;
};

type RuleKind = _RuleKinds[keyof _RuleKinds];

type RuleKindEnum = RuleKind;

type RuleOrString = Rule | string;

type State = {
    level: number;
    levels?: number[];
    prevState: Maybe<State>;
    rule: Maybe<ParseRule>;
    kind: Maybe<RuleKind>;
    name: Maybe<string>;
    type: Maybe<string>;
    step: number;
    needsSeperator: boolean;
    needsAdvance?: boolean;
    indentLevel?: number;
    inBlockstring?: boolean;
};

type Token = {
    kind: string;
    value: string;
};

type TokenPattern = string | ((char: string) => boolean) | RegExp;