import { Comment, Constant } from "..";
import { TokenRange } from "../token";
export declare enum NodeKind {
    ArithmeticExpression = "ArithmeticExpression",
    ArrayWrapper = "ArrayWrapper",
    AsExpression = "AsExpression",
    AsNullablePrimitiveType = "AsNullablePrimitiveType",
    AsType = "AsType",
    CatchExpression = "CatchExpression",
    Constant = "Constant",
    Csv = "Csv",
    EachExpression = "EachExpression",
    EqualityExpression = "EqualityExpression",
    ErrorHandlingExpression = "ErrorHandlingExpression",
    ErrorRaisingExpression = "ErrorRaisingExpression",
    FieldProjection = "FieldProjection",
    FieldSelector = "FieldSelector",
    FieldSpecification = "FieldSpecification",
    FieldSpecificationList = "FieldSpecificationList",
    FieldTypeSpecification = "FieldTypeSpecification",
    FunctionExpression = "FunctionExpression",
    FunctionType = "FunctionType",
    GeneralizedIdentifier = "GeneralizedIdentifier",
    GeneralizedIdentifierPairedAnyLiteral = "GeneralizedIdentifierPairedAnyLiteral",
    GeneralizedIdentifierPairedExpression = "GeneralizedIdentifierPairedExpression",
    Identifier = "Identifier",
    IdentifierExpression = "IdentifierExpression",
    IdentifierPairedExpression = "IdentifierPairedExpression",
    IfExpression = "IfExpression",
    InvokeExpression = "InvokeExpression",
    IsExpression = "IsExpression",
    IsNullablePrimitiveType = "IsNullablePrimitiveType",
    ItemAccessExpression = "ItemAccessExpression",
    LetExpression = "LetExpression",
    ListExpression = "ListExpression",
    ListLiteral = "ListLiteral",
    ListType = "ListType",
    LiteralExpression = "LiteralExpression",
    LogicalExpression = "LogicalExpression",
    MetadataExpression = "MetadataExpression",
    NotImplementedExpression = "NotImplementedExpression",
    NullablePrimitiveType = "NullablePrimitiveType",
    NullableType = "NullableType",
    NullCoalescingExpression = "NullCoalescingExpression",
    OtherwiseExpression = "OtherwiseExpression",
    Parameter = "Parameter",
    ParameterList = "ParameterList",
    ParenthesizedExpression = "ParenthesizedExpression",
    PrimitiveType = "PrimitiveType",
    RangeExpression = "RangeExpression",
    RecordExpression = "RecordExpression",
    RecordLiteral = "RecordLiteral",
    RecordType = "RecordType",
    RecursivePrimaryExpression = "RecursivePrimaryExpression",
    RelationalExpression = "RelationalExpression",
    Section = "Section",
    SectionMember = "SectionMember",
    TableType = "TableType",
    TypePrimaryType = "TypePrimaryType",
    UnaryExpression = "UnaryExpression"
}
export interface INode {
    readonly kind: NodeKind;
    readonly id: number;
    readonly attributeIndex: number | undefined;
    readonly tokenRange: TokenRange;
    readonly isLeaf: boolean;
}
export type TNode = TDocument | TAuxiliaryNodes;
export type TLeaf = GeneralizedIdentifier | Identifier | LiteralExpression | PrimitiveType | TConstant;
export type TAuxiliaryNodes = TConstant | FieldSpecification | FieldSpecificationList | FieldTypeSpecification | GeneralizedIdentifier | Identifier | SectionMember | TAnyLiteral | TArrayWrapper | TBinOpExpression | TCsv | TKeyValuePair | TListItem | TNullablePrimitiveType | TPairedConstant | TParameter | TParameterList | TType | TWrapped;
export type TArrayWrapper = IArrayWrapper<AsNullablePrimitiveType> | IArrayWrapper<IConstant<Constant.UnaryOperator>> | IArrayWrapper<IsNullablePrimitiveType> | IArrayWrapper<SectionMember> | IArrayWrapper<TRecursivePrimaryExpression> | TCsvArray;
export type TCsvArray = ICsvArray<TCsvType>;
export type TCsv = ICsv<TCsvType>;
export type TCsvType = FieldSelector | FieldSpecification | GeneralizedIdentifierPairedAnyLiteral | GeneralizedIdentifierPairedExpression | IdentifierPairedExpression | TParameter | TAnyLiteral | TExpression | TListItem;
export type TParameter = IParameter<TParameterType>;
export type TParameterList = IParameterList<TParameterType>;
export type TRecursivePrimaryExpression = RecursivePrimaryExpression | InvokeExpression | ItemAccessExpression | TFieldAccessExpression;
export type TBinOpExpressionNodeKind = NodeKind.ArithmeticExpression | NodeKind.AsExpression | NodeKind.EqualityExpression | NodeKind.IsExpression | NodeKind.LogicalExpression | NodeKind.NullCoalescingExpression | NodeKind.MetadataExpression | NodeKind.RelationalExpression;
export type TKeyValuePair = GeneralizedIdentifierPairedAnyLiteral | GeneralizedIdentifierPairedExpression | IdentifierPairedExpression;
export type TKeyValuePairNodeKind = NodeKind.GeneralizedIdentifierPairedAnyLiteral | NodeKind.GeneralizedIdentifierPairedExpression | NodeKind.IdentifierPairedExpression;
export type TPairedConstant = AsNullablePrimitiveType | AsType | CatchExpression | EachExpression | ErrorRaisingExpression | IsNullablePrimitiveType | NullablePrimitiveType | NullableType | OtherwiseExpression | TypePrimaryType;
export type TPairedConstantNodeKind = NodeKind.AsNullablePrimitiveType | NodeKind.AsType | NodeKind.CatchExpression | NodeKind.EachExpression | NodeKind.ErrorRaisingExpression | NodeKind.IsNullablePrimitiveType | NodeKind.NullablePrimitiveType | NodeKind.NullableType | NodeKind.OtherwiseExpression | NodeKind.TypePrimaryType;
export type TWrapped = InvokeExpression | ListExpression | ListLiteral | RecordExpression | RecordLiteral | TParameterList | FieldProjection | FieldSelector | FieldSpecificationList | ItemAccessExpression | ListType | ParenthesizedExpression;
export type TWrappedNodeKind = NodeKind.FieldProjection | NodeKind.FieldSelector | NodeKind.FieldSpecificationList | NodeKind.InvokeExpression | NodeKind.ItemAccessExpression | NodeKind.ListExpression | NodeKind.ListLiteral | NodeKind.ListType | NodeKind.ParameterList | NodeKind.ParenthesizedExpression | NodeKind.RecordExpression | NodeKind.RecordLiteral;
export type TDocument = Section | TExpression;
export interface Section extends INode {
    readonly kind: NodeKind.Section;
    readonly isLeaf: false;
    readonly literalAttributes: RecordLiteral | undefined;
    readonly sectionConstant: IConstant<Constant.KeywordConstant.Section>;
    readonly name: Identifier | undefined;
    readonly semicolonConstant: IConstant<Constant.MiscConstant.Semicolon>;
    readonly sectionMembers: IArrayWrapper<SectionMember>;
}
export interface SectionMember extends INode {
    readonly kind: NodeKind.SectionMember;
    readonly isLeaf: false;
    readonly precedingDirectives: ReadonlyArray<Comment.TDirective> | undefined;
    readonly literalAttributes: RecordLiteral | undefined;
    readonly sharedConstant: IConstant<Constant.KeywordConstant.Shared> | undefined;
    readonly namePairedExpression: IdentifierPairedExpression;
    readonly semicolonConstant: IConstant<Constant.MiscConstant.Semicolon>;
}
export type TExpression = TNullCoalescingExpression | EachExpression | FunctionExpression | LetExpression | IfExpression | ErrorRaisingExpression | TErrorHandlingExpression;
export type TLogicalExpression = LogicalExpression | TIsExpression;
export type TIsExpression = IsExpression | TAsExpression;
export type TNullablePrimitiveType = NullablePrimitiveType | PrimitiveType;
export type NullablePrimitiveType = IPairedConstant<NodeKind.NullablePrimitiveType, Constant.LanguageConstant.Nullable, PrimitiveType>;
export type IsNullablePrimitiveType = IPairedConstant<NodeKind.IsNullablePrimitiveType, Constant.KeywordConstant.Is, TNullablePrimitiveType>;
export interface PrimitiveType extends INode {
    readonly kind: NodeKind.PrimitiveType;
    readonly isLeaf: true;
    readonly primitiveTypeKind: Constant.PrimitiveTypeConstant;
}
export type TAsExpression = AsExpression | TEqualityExpression;
export type TEqualityExpression = EqualityExpression | TRelationalExpression;
export type TRelationalExpression = RelationalExpression | TArithmeticExpression;
export type TArithmeticExpression = ArithmeticExpression | TMetadataExpression;
export type TMetadataExpression = MetadataExpression | TUnaryExpression;
export type MetadataExpression = IBinOpExpression<NodeKind.MetadataExpression, TUnaryExpression, Constant.KeywordConstant.Meta, TUnaryExpression>;
export type TUnaryExpression = UnaryExpression | TTypeExpression;
export interface UnaryExpression extends INode {
    readonly kind: NodeKind.UnaryExpression;
    readonly isLeaf: false;
    readonly operators: IArrayWrapper<IConstant<Constant.UnaryOperator>>;
    readonly typeExpression: TTypeExpression;
}
export type TPrimaryExpression = LiteralExpression | ListExpression | RecordExpression | IdentifierExpression | ParenthesizedExpression | TFieldAccessExpression | TRecursivePrimaryExpression | NotImplementedExpression;
export declare enum LiteralKind {
    List = "List",
    Logical = "Logical",
    Null = "Null",
    Numeric = "Numeric",
    Record = "Record",
    Text = "Text"
}
export interface LiteralExpression extends INode {
    readonly kind: NodeKind.LiteralExpression;
    readonly isLeaf: true;
    readonly literal: string;
    readonly literalKind: Exclude<LiteralKind, LiteralKind.Record>;
}
export interface IdentifierExpression extends INode {
    readonly kind: NodeKind.IdentifierExpression;
    readonly isLeaf: false;
    readonly inclusiveConstant: IConstant<Constant.MiscConstant.AtSign> | undefined;
    readonly identifier: Identifier;
}
export interface ParenthesizedExpression extends IParenthesisWrapped<NodeKind.ParenthesizedExpression, TExpression> {
}
export interface NotImplementedExpression extends INode {
    readonly kind: NodeKind.NotImplementedExpression;
    readonly isLeaf: false;
    readonly ellipsisConstant: IConstant<Constant.MiscConstant.Ellipsis>;
}
export interface InvokeExpression extends IParenthesisWrapped<NodeKind.InvokeExpression, ICsvArray<TExpression>> {
}
export type TListItem = TExpression | RangeExpression;
export interface ListExpression extends IBraceWrapped<NodeKind.ListExpression, ICsvArray<TListItem>> {
}
export interface RangeExpression extends INode {
    readonly kind: NodeKind.RangeExpression;
    readonly isLeaf: false;
    readonly left: TExpression;
    readonly rangeConstant: IConstant<Constant.MiscConstant.DotDot>;
    readonly right: TExpression;
}
export type RecordExpression = IBracketWrapped<NodeKind.RecordExpression, ICsvArray<GeneralizedIdentifierPairedExpression>>;
export interface ItemAccessExpression extends IBraceWrapped<NodeKind.ItemAccessExpression, TExpression> {
    readonly optionalConstant: IConstant<Constant.MiscConstant.QuestionMark> | undefined;
}
export type TFieldAccessExpression = FieldSelector | FieldProjection;
export interface FieldSelector extends IBracketWrapped<NodeKind.FieldSelector, GeneralizedIdentifier> {
    readonly optionalConstant: IConstant<Constant.MiscConstant.QuestionMark> | undefined;
}
export interface FieldProjection extends IBracketWrapped<NodeKind.FieldProjection, ICsvArray<FieldSelector>> {
    readonly optionalConstant: IConstant<Constant.MiscConstant.QuestionMark> | undefined;
}
export interface FunctionExpression extends INode {
    readonly kind: NodeKind.FunctionExpression;
    readonly isLeaf: false;
    readonly parameters: IParameterList<AsNullablePrimitiveType | undefined>;
    readonly functionReturnType: AsNullablePrimitiveType | undefined;
    readonly fatArrowConstant: IConstant<Constant.MiscConstant.FatArrow>;
    readonly expression: TExpression;
}
export type EachExpression = IPairedConstant<NodeKind.EachExpression, Constant.KeywordConstant.Each, TExpression>;
export interface LetExpression extends INode {
    readonly kind: NodeKind.LetExpression;
    readonly letConstant: IConstant<Constant.KeywordConstant.Let>;
    readonly variableList: ICsvArray<IdentifierPairedExpression>;
    readonly inConstant: IConstant<Constant.KeywordConstant.In>;
    readonly expression: TExpression;
}
export interface IfExpression extends INode {
    readonly kind: NodeKind.IfExpression;
    readonly isLeaf: false;
    readonly ifConstant: IConstant<Constant.KeywordConstant.If>;
    readonly condition: TExpression;
    readonly thenConstant: IConstant<Constant.KeywordConstant.Then>;
    readonly trueExpression: TExpression;
    readonly elseConstant: IConstant<Constant.KeywordConstant.Else>;
    readonly falseExpression: TExpression;
}
export type TTypeExpression = TPrimaryExpression | TypePrimaryType;
export type TType = TExpression | TPrimaryType;
export type TPrimaryType = PrimitiveType | FunctionType | ListType | NullableType | RecordType | TableType;
export interface FunctionType extends INode {
    readonly kind: NodeKind.FunctionType;
    readonly isLeaf: false;
    readonly functionConstant: IConstant<Constant.PrimitiveTypeConstant.Function>;
    readonly parameters: IParameterList<AsType>;
    readonly functionReturnType: AsType;
}
export interface ListType extends IBraceWrapped<NodeKind.ListType, TType> {
}
export type NullableType = IPairedConstant<NodeKind.NullableType, Constant.LanguageConstant.Nullable, TType>;
export interface RecordType extends INode {
    readonly kind: NodeKind.RecordType;
    readonly isLeaf: false;
    readonly fields: FieldSpecificationList;
}
export interface TableType extends INode {
    readonly kind: NodeKind.TableType;
    readonly isLeaf: false;
    readonly tableConstant: IConstant<Constant.PrimitiveTypeConstant.Table>;
    readonly rowType: FieldSpecificationList | TPrimaryExpression;
}
export type ErrorRaisingExpression = IPairedConstant<NodeKind.ErrorRaisingExpression, Constant.KeywordConstant.Error, TExpression>;
export declare enum ErrorHandlerKind {
    Catch = "Catch",
    Otherwise = "Otherwise"
}
export interface IErrorHandlingExpression<K extends ErrorHandlerKind, H> extends INode {
    readonly kind: NodeKind.ErrorHandlingExpression;
    readonly handlerKind: K;
    readonly isLeaf: false;
    readonly tryConstant: IConstant<Constant.KeywordConstant.Try>;
    readonly protectedExpression: TExpression;
    readonly handler: H | undefined;
}
export type ErrorHandlingCatchExpression = IErrorHandlingExpression<ErrorHandlerKind.Catch, CatchExpression>;
export type ErrorHandlingOtherwiseExpression = IErrorHandlingExpression<ErrorHandlerKind.Otherwise, OtherwiseExpression>;
export type TErrorHandlingExpression = ErrorHandlingCatchExpression | ErrorHandlingOtherwiseExpression;
export type CatchExpression = IPairedConstant<NodeKind.CatchExpression, Constant.LanguageConstant.Catch, FunctionExpression>;
export type OtherwiseExpression = IPairedConstant<NodeKind.OtherwiseExpression, Constant.KeywordConstant.Otherwise, TExpression>;
export interface RecursivePrimaryExpression extends INode {
    readonly kind: NodeKind.RecursivePrimaryExpression;
    readonly isLeaf: false;
    readonly head: TPrimaryExpression;
    readonly recursiveExpressions: IArrayWrapper<InvokeExpression | ItemAccessExpression | TFieldAccessExpression>;
}
export type TypePrimaryType = IPairedConstant<NodeKind.TypePrimaryType, Constant.KeywordConstant.Type, TPrimaryType>;
export type TAnyLiteral = ListLiteral | LiteralExpression | RecordLiteral;
export interface ListLiteral extends IBraceWrapped<NodeKind.ListLiteral, ICsvArray<TAnyLiteral>> {
    readonly literalKind: LiteralKind.List;
}
export interface RecordLiteral extends IBracketWrapped<NodeKind.RecordLiteral, ICsvArray<GeneralizedIdentifierPairedAnyLiteral>> {
    readonly literalKind: LiteralKind.Record;
}
export interface IArrayWrapper<T> extends INode {
    readonly kind: NodeKind.ArrayWrapper;
    readonly elements: ReadonlyArray<T>;
}
export type ICsvArray<T extends TCsvType> = IArrayWrapper<ICsv<T>>;
export interface ICsv<T> extends INode {
    readonly kind: NodeKind.Csv;
    readonly node: T;
    readonly commaConstant: IConstant<Constant.MiscConstant.Comma> | undefined;
}
export interface IKeyValuePair<Kind extends TKeyValuePairNodeKind, Key, Value> extends INode {
    readonly kind: Kind;
    readonly precedingDirectives: ReadonlyArray<Comment.TDirective> | undefined;
    readonly key: Key;
    readonly equalConstant: IConstant<Constant.MiscConstant.Equal>;
    readonly value: Value;
}
export interface IPairedConstant<Kind extends TPairedConstantNodeKind, ConstantKind extends Constant.TConstant, Paired> extends INode {
    readonly kind: Kind;
    readonly constant: IConstant<ConstantKind>;
    readonly paired: Paired;
}
export interface IWrapped<Kind extends TWrappedNodeKind, Open extends Constant.WrapperConstant, Content, Close extends Constant.WrapperConstant> extends INode {
    readonly kind: Kind;
    readonly openWrapperConstant: IConstant<Open>;
    readonly content: Content;
    readonly closeWrapperConstant: IConstant<Close>;
}
export type IBraceWrapped<Kind extends TWrappedNodeKind, Content> = IWrapped<Kind, Constant.WrapperConstant.LeftBrace, Content, Constant.WrapperConstant.RightBrace>;
export type IBracketWrapped<Kind extends TWrappedNodeKind, Content> = IWrapped<Kind, Constant.WrapperConstant.LeftBracket, Content, Constant.WrapperConstant.RightBracket>;
export type IParenthesisWrapped<Kind extends TWrappedNodeKind, Content> = IWrapped<Kind, Constant.WrapperConstant.LeftParenthesis, Content, Constant.WrapperConstant.RightParenthesis>;
export type TBinOpExpression = ArithmeticExpression | AsExpression | EqualityExpression | IsExpression | LogicalExpression | MetadataExpression | NullCoalescingExpression | RelationalExpression | TBinOpExpressionSubtype;
export type TBinOpExpressionSubtype = IBinOpExpression<NodeKind.AsExpression, TNullablePrimitiveType, Constant.KeywordConstant.As, TNullablePrimitiveType> | IBinOpExpression<NodeKind.IsExpression, TNullablePrimitiveType, Constant.KeywordConstant.Is, TNullablePrimitiveType>;
export interface IBinOpExpression<Kind extends TBinOpExpressionNodeKind, Left, OperatorKind extends Constant.TBinOpExpressionOperator, Right> extends INode {
    readonly kind: Kind;
    readonly left: Left;
    readonly operatorConstant: IConstant<OperatorKind>;
    readonly right: Left | Right | IBinOpExpression<Kind, Left, OperatorKind, Right> | IBinOpExpression<Kind, Right, OperatorKind, Right>;
}
export type ArithmeticExpression = IBinOpExpression<NodeKind.ArithmeticExpression, TArithmeticExpression, Constant.ArithmeticOperator, TArithmeticExpression>;
export type AsExpression = IBinOpExpression<NodeKind.AsExpression, TAsExpression, Constant.KeywordConstant.As, TNullablePrimitiveType>;
export type EqualityExpression = IBinOpExpression<NodeKind.EqualityExpression, TEqualityExpression, Constant.EqualityOperator, TEqualityExpression>;
export type IsExpression = IBinOpExpression<NodeKind.IsExpression, TIsExpression, Constant.KeywordConstant.Is, TNullablePrimitiveType>;
export type LogicalExpression = IBinOpExpression<NodeKind.LogicalExpression, TLogicalExpression, Constant.LogicalOperator, TLogicalExpression>;
export type RelationalExpression = IBinOpExpression<NodeKind.RelationalExpression, TRelationalExpression, Constant.RelationalOperator, TRelationalExpression>;
export type GeneralizedIdentifierPairedAnyLiteral = IKeyValuePair<NodeKind.GeneralizedIdentifierPairedAnyLiteral, GeneralizedIdentifier, TAnyLiteral>;
export interface GeneralizedIdentifierPairedExpression extends IKeyValuePair<NodeKind.GeneralizedIdentifierPairedExpression, GeneralizedIdentifier, TExpression> {
}
export type IdentifierPairedExpression = IKeyValuePair<NodeKind.IdentifierPairedExpression, Identifier, TExpression>;
export type TParameterType = AsType | AsNullablePrimitiveType | undefined;
export type IParameterList<T extends TParameterType> = IParenthesisWrapped<NodeKind.ParameterList, ICsvArray<IParameter<T>>>;
export interface IParameter<T extends TParameterType> extends INode {
    readonly kind: NodeKind.Parameter;
    readonly isLeaf: false;
    readonly optionalConstant: IConstant<Constant.LanguageConstant.Optional> | undefined;
    readonly name: Identifier;
    readonly parameterType: T;
}
export type AsNullablePrimitiveType = IPairedConstant<NodeKind.AsNullablePrimitiveType, Constant.KeywordConstant.As, TNullablePrimitiveType>;
export type AsType = IPairedConstant<NodeKind.AsType, Constant.KeywordConstant.As, TType>;
export interface IConstant<ConstantKind extends Constant.TConstant> extends INode {
    readonly kind: NodeKind.Constant;
    readonly isLeaf: true;
    readonly constantKind: ConstantKind;
}
export type TConstant = IConstant<Constant.TConstant>;
export type TBinOpExpressionConstant = IConstant<Constant.TBinOpExpressionOperator>;
export type TNullCoalescingExpression = NullCoalescingExpression | TLogicalExpression;
export type NullCoalescingExpression = IBinOpExpression<NodeKind.NullCoalescingExpression, TLogicalExpression, Constant.MiscConstant.NullCoalescingOperator, TLogicalExpression>;
export interface FieldSpecification extends INode {
    readonly kind: NodeKind.FieldSpecification;
    readonly isLeaf: false;
    readonly optionalConstant: IConstant<Constant.LanguageConstant.Optional> | undefined;
    readonly name: GeneralizedIdentifier;
    readonly fieldTypeSpecification: FieldTypeSpecification | undefined;
}
export interface FieldSpecificationList extends IBracketWrapped<NodeKind.FieldSpecificationList, ICsvArray<FieldSpecification>> {
    readonly openRecordMarkerConstant: IConstant<Constant.MiscConstant.Ellipsis> | undefined;
}
export interface FieldTypeSpecification extends INode {
    readonly kind: NodeKind.FieldTypeSpecification;
    readonly equalConstant: IConstant<Constant.MiscConstant.Equal>;
    readonly fieldType: TType;
}
export interface GeneralizedIdentifier extends INode {
    readonly kind: NodeKind.GeneralizedIdentifier;
    readonly isLeaf: true;
    readonly literal: string;
}
export interface Identifier extends INode {
    readonly kind: NodeKind.Identifier;
    readonly isLeaf: true;
    readonly literal: string;
    readonly identifierContextKind: IdentifierContextKind;
}
export declare enum IdentifierContextKind {
    Key = "Key",
    Keyword = "Keyword",
    Parameter = "Parameter",
    Value = "Value"
}
export declare const NodeKindsForTFieldAccessExpression: Set<NodeKind>;
export declare const NodeKindsForTRecursivePrimaryExpression: Set<NodeKind>;
export declare const NodeKindsForTPrimaryExpression: Set<NodeKind>;
export declare const NodeKindsForTTypeExpression: Set<NodeKind>;
export declare const NodeKindsForTUnaryExpression: Set<NodeKind>;
export declare const NodeKindsForTMetadataExpression: Set<NodeKind>;
export declare const NodeKindsForTArithmeticExpression: Set<NodeKind>;
export declare const NodeKindsForTRelationalExpression: Set<NodeKind>;
export declare const NodeKindsForTEqualityExpression: Set<NodeKind>;
export declare const NodeKindsForTAsExpression: Set<NodeKind>;
export declare const NodeKindsForTIsExpression: Set<NodeKind>;
export declare const NodeKindsForTLogicalExpression: Set<NodeKind>;
export declare const NodeKindsForTNullablePrimitiveType: Set<NodeKind>;
export declare const NodeKindsForTNullCoalescingExpression: Set<NodeKind>;
export declare const NodeKindsForTExpression: Set<NodeKind>;
export declare const NodeKindsForTListItem: Set<NodeKind>;
export declare const NodeKindsForTPrimaryType: Set<NodeKind>;
export declare const NodeKindsForTType: Set<NodeKind>;
export declare const NodeKindsForTAnyLiteral: Set<NodeKind>;
export declare const NodeKindsForTLeaf: Set<NodeKind>;