@tslite/parser 1.10.0 → 1.13.0

package/dist/types.d.ts

@@ -0,0 +1,2626 @@
+import { Map } from "./_namespaces/ts.js";
+import type { Iterator, MapLike, ReadonlyMap } from "./_namespaces/ts.js";
+export type Path = string & {
+    __pathBrand: any;
+};
+export type MatchingKeys<TRecord, TMatch, K extends keyof TRecord = keyof TRecord> = K extends (TRecord[K] extends TMatch ? K : never) ? K : never;
+export interface TextRange {
+    pos: number;
+    end: number;
+}
+export type KeywordSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.StringKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
+export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
+export declare enum SyntaxKind {
+    Unknown = 0,
+    EndOfFileToken = 1,
+    SingleLineCommentTrivia = 2,
+    MultiLineCommentTrivia = 3,
+    NewLineTrivia = 4,
+    WhitespaceTrivia = 5,
+    ShebangTrivia = 6,
+    ConflictMarkerTrivia = 7,
+    NumericLiteral = 8,
+    BigIntLiteral = 9,
+    StringLiteral = 10,
+    JsxText = 11,
+    JsxTextAllWhiteSpaces = 12,
+    RegularExpressionLiteral = 13,
+    NoSubstitutionTemplateLiteral = 14,
+    TemplateHead = 15,
+    TemplateMiddle = 16,
+    TemplateTail = 17,
+    OpenBraceToken = 18,
+    CloseBraceToken = 19,
+    OpenParenToken = 20,
+    CloseParenToken = 21,
+    OpenBracketToken = 22,
+    CloseBracketToken = 23,
+    DotToken = 24,
+    DotDotDotToken = 25,
+    SemicolonToken = 26,
+    CommaToken = 27,
+    QuestionDotToken = 28,
+    LessThanToken = 29,
+    LessThanSlashToken = 30,
+    GreaterThanToken = 31,
+    LessThanEqualsToken = 32,
+    GreaterThanEqualsToken = 33,
+    EqualsEqualsToken = 34,
+    ExclamationEqualsToken = 35,
+    EqualsEqualsEqualsToken = 36,
+    ExclamationEqualsEqualsToken = 37,
+    EqualsGreaterThanToken = 38,
+    PlusToken = 39,
+    MinusToken = 40,
+    AsteriskToken = 41,
+    AsteriskAsteriskToken = 42,
+    SlashToken = 43,
+    PercentToken = 44,
+    PlusPlusToken = 45,
+    MinusMinusToken = 46,
+    LessThanLessThanToken = 47,
+    GreaterThanGreaterThanToken = 48,
+    GreaterThanGreaterThanGreaterThanToken = 49,
+    AmpersandToken = 50,
+    BarToken = 51,
+    CaretToken = 52,
+    ExclamationToken = 53,
+    TildeToken = 54,
+    AmpersandAmpersandToken = 55,
+    BarBarToken = 56,
+    QuestionToken = 57,
+    ColonToken = 58,
+    AtToken = 59,
+    QuestionQuestionToken = 60,
+    /** Nenhum scanner o produz (só o do JSDoc o produzia): a crase começa um template. Fica para não renumerar. */
+    BacktickToken = 61,
+    EqualsToken = 62,
+    PlusEqualsToken = 63,
+    MinusEqualsToken = 64,
+    AsteriskEqualsToken = 65,
+    AsteriskAsteriskEqualsToken = 66,
+    SlashEqualsToken = 67,
+    PercentEqualsToken = 68,
+    LessThanLessThanEqualsToken = 69,
+    GreaterThanGreaterThanEqualsToken = 70,
+    GreaterThanGreaterThanGreaterThanEqualsToken = 71,
+    AmpersandEqualsToken = 72,
+    BarEqualsToken = 73,
+    CaretEqualsToken = 74,
+    Identifier = 75,
+    PrivateIdentifier = 76,
+    BreakKeyword = 77,
+    CaseKeyword = 78,
+    CatchKeyword = 79,
+    ClassKeyword = 80,
+    ConstKeyword = 81,
+    ContinueKeyword = 82,
+    DebuggerKeyword = 83,
+    DefaultKeyword = 84,
+    DeleteKeyword = 85,
+    DoKeyword = 86,
+    ElseKeyword = 87,
+    EnumKeyword = 88,
+    ExportKeyword = 89,
+    ExtendsKeyword = 90,
+    FalseKeyword = 91,
+    FinallyKeyword = 92,
+    ForKeyword = 93,
+    FunctionKeyword = 94,
+    IfKeyword = 95,
+    ImportKeyword = 96,
+    InKeyword = 97,
+    InstanceOfKeyword = 98,
+    NewKeyword = 99,
+    NullKeyword = 100,
+    ReturnKeyword = 101,
+    SuperKeyword = 102,
+    SwitchKeyword = 103,
+    ThisKeyword = 104,
+    ThrowKeyword = 105,
+    TrueKeyword = 106,
+    TryKeyword = 107,
+    TypeOfKeyword = 108,
+    VarKeyword = 109,
+    VoidKeyword = 110,
+    WhileKeyword = 111,
+    WithKeyword = 112,
+    ImplementsKeyword = 113,
+    InterfaceKeyword = 114,
+    LetKeyword = 115,
+    PackageKeyword = 116,
+    PrivateKeyword = 117,
+    ProtectedKeyword = 118,
+    PublicKeyword = 119,
+    StaticKeyword = 120,
+    YieldKeyword = 121,
+    AbstractKeyword = 122,
+    AsKeyword = 123,
+    AssertsKeyword = 124,
+    AnyKeyword = 125,
+    AsyncKeyword = 126,
+    AwaitKeyword = 127,
+    BooleanKeyword = 128,
+    ConstructorKeyword = 129,
+    DeclareKeyword = 130,
+    GetKeyword = 131,
+    InferKeyword = 132,
+    IsKeyword = 133,
+    KeyOfKeyword = 134,
+    ModuleKeyword = 135,
+    NamespaceKeyword = 136,
+    NeverKeyword = 137,
+    ReadonlyKeyword = 138,
+    RequireKeyword = 139,
+    NumberKeyword = 140,
+    ObjectKeyword = 141,
+    SetKeyword = 142,
+    StringKeyword = 143,
+    SymbolKeyword = 144,
+    TypeKeyword = 145,
+    UndefinedKeyword = 146,
+    UniqueKeyword = 147,
+    UnknownKeyword = 148,
+    FromKeyword = 149,
+    GlobalKeyword = 150,
+    BigIntKeyword = 151,
+    OfKeyword = 152,// LastKeyword and LastToken and LastContextualKeyword
+    QualifiedName = 153,
+    ComputedPropertyName = 154,
+    TypeParameter = 155,
+    Parameter = 156,
+    Decorator = 157,
+    PropertySignature = 158,
+    PropertyDeclaration = 159,
+    MethodSignature = 160,
+    MethodDeclaration = 161,
+    Constructor = 162,
+    GetAccessor = 163,
+    SetAccessor = 164,
+    CallSignature = 165,
+    ConstructSignature = 166,
+    IndexSignature = 167,
+    TypePredicate = 168,
+    TypeReference = 169,
+    FunctionType = 170,
+    ConstructorType = 171,
+    TypeQuery = 172,
+    TypeLiteral = 173,
+    ArrayType = 174,
+    TupleType = 175,
+    OptionalType = 176,
+    RestType = 177,
+    UnionType = 178,
+    IntersectionType = 179,
+    ConditionalType = 180,
+    InferType = 181,
+    ParenthesizedType = 182,
+    ThisType = 183,
+    TypeOperator = 184,
+    IndexedAccessType = 185,
+    MappedType = 186,
+    LiteralType = 187,
+    ImportType = 188,
+    ObjectBindingPattern = 189,
+    ArrayBindingPattern = 190,
+    BindingElement = 191,
+    ArrayLiteralExpression = 192,
+    ObjectLiteralExpression = 193,
+    PropertyAccessExpression = 194,
+    ElementAccessExpression = 195,
+    CallExpression = 196,
+    NewExpression = 197,
+    TaggedTemplateExpression = 198,
+    TypeAssertionExpression = 199,
+    ParenthesizedExpression = 200,
+    FunctionExpression = 201,
+    ArrowFunction = 202,
+    DeleteExpression = 203,
+    TypeOfExpression = 204,
+    VoidExpression = 205,
+    AwaitExpression = 206,
+    PrefixUnaryExpression = 207,
+    PostfixUnaryExpression = 208,
+    BinaryExpression = 209,
+    ConditionalExpression = 210,
+    TemplateExpression = 211,
+    YieldExpression = 212,
+    SpreadElement = 213,
+    ClassExpression = 214,
+    OmittedExpression = 215,
+    ExpressionWithTypeArguments = 216,
+    AsExpression = 217,
+    NonNullExpression = 218,
+    MetaProperty = 219,
+    SyntheticExpression = 220,
+    TemplateSpan = 221,
+    SemicolonClassElement = 222,
+    Block = 223,
+    EmptyStatement = 224,
+    VariableStatement = 225,
+    ExpressionStatement = 226,
+    IfStatement = 227,
+    DoStatement = 228,
+    WhileStatement = 229,
+    ForStatement = 230,
+    ForInStatement = 231,
+    ForOfStatement = 232,
+    ContinueStatement = 233,
+    BreakStatement = 234,
+    ReturnStatement = 235,
+    WithStatement = 236,
+    SwitchStatement = 237,
+    LabeledStatement = 238,
+    ThrowStatement = 239,
+    TryStatement = 240,
+    DebuggerStatement = 241,
+    VariableDeclaration = 242,
+    VariableDeclarationList = 243,
+    FunctionDeclaration = 244,
+    ClassDeclaration = 245,
+    InterfaceDeclaration = 246,
+    TypeAliasDeclaration = 247,
+    EnumDeclaration = 248,
+    ModuleDeclaration = 249,
+    ModuleBlock = 250,
+    CaseBlock = 251,
+    NamespaceExportDeclaration = 252,
+    ImportEqualsDeclaration = 253,
+    ImportDeclaration = 254,
+    ImportClause = 255,
+    NamespaceImport = 256,
+    NamedImports = 257,
+    ImportSpecifier = 258,
+    ExportAssignment = 259,
+    ExportDeclaration = 260,
+    NamedExports = 261,
+    NamespaceExport = 262,
+    ExportSpecifier = 263,
+    MissingDeclaration = 264,
+    ExternalModuleReference = 265,
+    JsxElement = 266,
+    JsxSelfClosingElement = 267,
+    JsxOpeningElement = 268,
+    JsxClosingElement = 269,
+    JsxFragment = 270,
+    JsxOpeningFragment = 271,
+    JsxClosingFragment = 272,
+    JsxAttribute = 273,
+    JsxAttributes = 274,
+    JsxSpreadAttribute = 275,
+    JsxExpression = 276,
+    CaseClause = 277,
+    DefaultClause = 278,
+    HeritageClause = 279,
+    CatchClause = 280,
+    PropertyAssignment = 281,
+    ShorthandPropertyAssignment = 282,
+    SpreadAssignment = 283,
+    EnumMember = 284,
+    UnparsedPrologue = 285,
+    UnparsedPrepend = 286,
+    UnparsedText = 287,
+    UnparsedInternalText = 288,
+    UnparsedSyntheticReference = 289,
+    SourceFile = 290,
+    Bundle = 291,
+    UnparsedSource = 292,
+    InputFiles = 293,
+    JSDocTypeExpression = 294,
+    JSDocAllType = 295,
+    JSDocUnknownType = 296,
+    JSDocNullableType = 297,
+    JSDocNonNullableType = 298,
+    JSDocOptionalType = 299,
+    JSDocFunctionType = 300,
+    JSDocVariadicType = 301,
+    JSDocNamepathType = 302,
+    JSDocComment = 303,
+    JSDocTypeLiteral = 304,
+    JSDocSignature = 305,
+    JSDocTag = 306,
+    JSDocAugmentsTag = 307,
+    JSDocImplementsTag = 308,
+    JSDocAuthorTag = 309,
+    JSDocClassTag = 310,
+    JSDocPublicTag = 311,
+    JSDocPrivateTag = 312,
+    JSDocProtectedTag = 313,
+    JSDocReadonlyTag = 314,
+    JSDocCallbackTag = 315,
+    JSDocEnumTag = 316,
+    JSDocParameterTag = 317,
+    JSDocReturnTag = 318,
+    JSDocThisTag = 319,
+    JSDocTypeTag = 320,
+    JSDocTemplateTag = 321,
+    JSDocTypedefTag = 322,
+    JSDocPropertyTag = 323,
+    SyntaxList = 324,
+    NotEmittedStatement = 325,
+    PartiallyEmittedExpression = 326,
+    CommaListExpression = 327,
+    MergeDeclarationMarker = 328,
+    EndOfDeclarationMarker = 329,
+    SyntheticReferenceExpression = 330,
+    Count = 331,
+    FirstAssignment = 62,
+    LastAssignment = 74,
+    FirstCompoundAssignment = 63,
+    LastCompoundAssignment = 74,
+    FirstReservedWord = 77,
+    LastReservedWord = 112,
+    FirstKeyword = 77,
+    LastKeyword = 152,
+    FirstFutureReservedWord = 113,
+    LastFutureReservedWord = 121,
+    FirstTypeNode = 168,
+    LastTypeNode = 188,
+    FirstPunctuation = 18,
+    LastPunctuation = 74,
+    FirstToken = 0,
+    LastToken = 152,
+    FirstTriviaToken = 2,
+    LastTriviaToken = 7,
+    FirstLiteralToken = 8,
+    LastLiteralToken = 14,
+    FirstTemplateToken = 14,
+    LastTemplateToken = 17,
+    FirstBinaryOperator = 29,
+    LastBinaryOperator = 74,
+    FirstStatement = 225,
+    LastStatement = 241,
+    FirstNode = 153,
+    FirstJSDocNode = 294,
+    LastJSDocNode = 323,
+    FirstJSDocTagNode = 306,
+    LastJSDocTagNode = 323,
+    FirstContextualKeyword = 122,
+    LastContextualKeyword = 152
+}
+export declare enum NodeFlags {
+    None = 0,
+    Let = 1,// Variable declaration
+    Const = 2,// Variable declaration
+    NestedNamespace = 4,// Namespace declaration
+    Synthesized = 8,// Node was synthesized during transformation
+    Namespace = 16,// Namespace declaration
+    OptionalChain = 32,// Chained MemberExpression rooted to a pseudo-OptionalExpression
+    ExportContext = 64,// Export context (initialized by binding)
+    HasImplicitReturn = 256,// If function implicitly returns on one of codepaths (initialized by binding)
+    HasExplicitReturn = 512,// If function has explicit reachable return on one of codepaths (initialized by binding)
+    GlobalAugmentation = 1024,// Set if module declaration is an augmentation for the global scope
+    HasAsyncFunctions = 2048,// If the file has async functions (initialized by binding)
+    DisallowInContext = 4096,// If node was parsed in a context where 'in-expressions' are not allowed
+    AwaitContext = 32768,// If node was parsed in the 'await' context created when parsing an async function
+    ThisNodeHasError = 65536,// If the parser encountered an error when parsing the code that created this node
+    JavaScriptFile = 131072,// If node was parsed in a JavaScript
+    ThisNodeOrAnySubNodesHasError = 262144,// If this node or any of its children had an error
+    HasAggregatedChildData = 524288,// If we've computed data from children and cached it in this node
+    PossiblyContainsDynamicImport = 1048576,
+    PossiblyContainsImportMeta = 2097152,
+    Ambient = 8388608,// If node was inside an ambient context -- a declaration file, or inside something with the `declare` modifier.
+    JsonFile = 33554432,// If node was parsed in a Json
+    TypeCached = 67108864,// If a type was cached for node at any point
+    BlockScoped = 3,
+    ReachabilityCheckFlags = 768,
+    ReachabilityAndEmitFlags = 2816,
+    ContextFlags = 8556544,
+    TypeExcludesFlags = 32768,
+    PermanentlySetIncrementalFlags = 3145728
+}
+export declare enum ModifierFlags {
+    None = 0,
+    Export = 1,// Declarations
+    Ambient = 2,// Declarations
+    Readonly = 64,// Property/Method
+    Async = 256,// Property/Method/Function
+    HasComputedFlags = 536870912,// Modifier flags have been computed
+    TypeScriptModifier = 66,
+    All = 323
+}
+export interface Node extends TextRange {
+    kind: SyntaxKind;
+    flags: NodeFlags;
+    modifierFlagsCache: ModifierFlags;
+    transformFlags: TransformFlags;
+    modifiers?: ModifiersArray;
+    id?: number;
+    parent: Node;
+    original?: Node;
+    symbol: Symbol;
+    locals?: SymbolTable;
+    nextContainer?: Node;
+    localSymbol?: Symbol;
+    flowNode?: FlowNode;
+    emitNode?: EmitNode;
+}
+export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration;
+export type HasTypeArguments = CallExpression | JsxOpeningElement | JsxSelfClosingElement;
+export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
+export type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertySignature | PropertyAssignment;
+export type MutableNodeArray<T extends Node> = NodeArray<T> & T[];
+export interface NodeArray<T extends Node> extends ReadonlyArray<T>, TextRange {
+    hasTrailingComma?: boolean;
+    transformFlags: TransformFlags;
+}
+export interface Token<TKind extends SyntaxKind> extends Node {
+    kind: TKind;
+}
+export type DotToken = Token<SyntaxKind.DotToken>;
+export type DotDotDotToken = Token<SyntaxKind.DotDotDotToken>;
+export type QuestionToken = Token<SyntaxKind.QuestionToken>;
+export type QuestionDotToken = Token<SyntaxKind.QuestionDotToken>;
+export type ExclamationToken = Token<SyntaxKind.ExclamationToken>;
+export type ColonToken = Token<SyntaxKind.ColonToken>;
+export type EqualsToken = Token<SyntaxKind.EqualsToken>;
+export type EqualsGreaterThanToken = Token<SyntaxKind.EqualsGreaterThanToken>;
+export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken>;
+export type ReadonlyToken = Token<SyntaxKind.ReadonlyKeyword>;
+export type AwaitKeywordToken = Token<SyntaxKind.AwaitKeyword>;
+export type PlusToken = Token<SyntaxKind.PlusToken>;
+export type MinusToken = Token<SyntaxKind.MinusToken>;
+export type AssertsToken = Token<SyntaxKind.AssertsKeyword>;
+export type Modifier = Token<SyntaxKind.AsyncKeyword> | Token<SyntaxKind.DeclareKeyword> | Token<SyntaxKind.ExportKeyword> | Token<SyntaxKind.ReadonlyKeyword>;
+export type ModifiersArray = NodeArray<Modifier>;
+export declare enum GeneratedIdentifierFlags {
+    None = 0,// Not automatically generated.
+    Auto = 1,// Automatically generated identifier.
+    Loop = 2,// Automatically generated identifier with a preference for '_i'.
+    Unique = 3,// Unique name based on the 'text' property.
+    Node = 4,// Unique name based on the node in the 'original' property.
+    KindMask = 7,// Mask to extract the kind of identifier from its flags.
+    ReservedInNestedScopes = 8,// Reserve the generated name in nested scopes
+    Optimistic = 16,// First instance won't use '_#' if there's no conflict
+    FileLevel = 32
+}
+export interface Identifier extends PrimaryExpression, Declaration {
+    kind: SyntaxKind.Identifier;
+    /**
+     * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.)
+     * Text of identifier, but if the identifier begins with two underscores, this will begin with three.
+     */
+    escapedText: __String;
+    originalKeywordKind?: SyntaxKind;
+    autoGenerateFlags?: GeneratedIdentifierFlags;
+    autoGenerateId?: number;
+    typeArguments?: NodeArray<TypeNode | TypeParameterDeclaration>;
+}
+export interface TransientIdentifier extends Identifier {
+    resolvedSymbol: Symbol;
+}
+export interface GeneratedIdentifier extends Identifier {
+    autoGenerateFlags: GeneratedIdentifierFlags;
+}
+export interface QualifiedName extends Node {
+    kind: SyntaxKind.QualifiedName;
+    left: EntityName;
+    right: Identifier;
+}
+export type EntityName = Identifier | QualifiedName;
+export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
+export type DeclarationName = Identifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern | EntityNameExpression;
+export interface Declaration extends Node {
+    _declarationBrand: any;
+}
+export interface NamedDeclaration extends Declaration {
+    name?: DeclarationName;
+}
+export interface DynamicNamedDeclaration extends NamedDeclaration {
+    name: ComputedPropertyName;
+}
+export interface DynamicNamedBinaryExpression extends BinaryExpression {
+    left: ElementAccessExpression;
+}
+export interface LateBoundDeclaration extends DynamicNamedDeclaration {
+    name: LateBoundName;
+}
+export interface DeclarationStatement extends NamedDeclaration, Statement {
+    name?: Identifier | StringLiteral | NumericLiteral;
+}
+export interface ComputedPropertyName extends Node {
+    parent: Declaration;
+    kind: SyntaxKind.ComputedPropertyName;
+    expression: Expression;
+}
+export interface LateBoundName extends ComputedPropertyName {
+    expression: EntityNameExpression;
+}
+export interface TypeParameterDeclaration extends NamedDeclaration {
+    kind: SyntaxKind.TypeParameter;
+    parent: DeclarationWithTypeParameterChildren | InferTypeNode;
+    name: Identifier;
+    /** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */
+    constraint?: TypeNode;
+    default?: TypeNode;
+    expression?: Expression;
+}
+export interface SignatureDeclarationBase extends NamedDeclaration {
+    kind: SignatureDeclaration["kind"];
+    name?: PropertyName;
+    typeParameters?: NodeArray<TypeParameterDeclaration>;
+    parameters: NodeArray<ParameterDeclaration>;
+    type?: TypeNode;
+    typeArguments?: NodeArray<TypeNode>;
+}
+export type SignatureDeclaration = CallSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ArrowFunction;
+export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
+    kind: SyntaxKind.CallSignature;
+}
+export type BindingName = Identifier | BindingPattern;
+export interface VariableDeclaration extends NamedDeclaration {
+    kind: SyntaxKind.VariableDeclaration;
+    parent: VariableDeclarationList | CatchClause;
+    name: BindingName;
+    exclamationToken?: ExclamationToken;
+    type?: TypeNode;
+    initializer?: Expression;
+}
+export interface VariableDeclarationList extends Node {
+    kind: SyntaxKind.VariableDeclarationList;
+    parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;
+    declarations: NodeArray<VariableDeclaration>;
+}
+export interface ParameterDeclaration extends NamedDeclaration {
+    kind: SyntaxKind.Parameter;
+    parent: SignatureDeclaration;
+    dotDotDotToken?: DotDotDotToken;
+    name: BindingName;
+    questionToken?: QuestionToken;
+    type?: TypeNode;
+    initializer?: Expression;
+}
+export interface BindingElement extends NamedDeclaration {
+    kind: SyntaxKind.BindingElement;
+    parent: BindingPattern;
+    propertyName?: PropertyName;
+    dotDotDotToken?: DotDotDotToken;
+    name: BindingName;
+    initializer?: Expression;
+}
+export type BindingElementGrandparent = BindingElement["parent"]["parent"];
+export interface PropertySignature extends TypeElement {
+    kind: SyntaxKind.PropertySignature;
+    name: PropertyName;
+    questionToken?: QuestionToken;
+    type?: TypeNode;
+    initializer?: Expression;
+}
+export interface ObjectLiteralElement extends NamedDeclaration {
+    _objectLiteralBrand: any;
+    name?: PropertyName;
+}
+/** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */
+export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment;
+export interface PropertyAssignment extends ObjectLiteralElement {
+    parent: ObjectLiteralExpression;
+    kind: SyntaxKind.PropertyAssignment;
+    name: PropertyName;
+    questionToken?: QuestionToken;
+    initializer: Expression;
+}
+export interface ShorthandPropertyAssignment extends ObjectLiteralElement {
+    parent: ObjectLiteralExpression;
+    kind: SyntaxKind.ShorthandPropertyAssignment;
+    name: Identifier;
+    questionToken?: QuestionToken;
+    exclamationToken?: ExclamationToken;
+    equalsToken?: Token<SyntaxKind.EqualsToken>;
+    objectAssignmentInitializer?: Expression;
+}
+export interface SpreadAssignment extends ObjectLiteralElement {
+    parent: ObjectLiteralExpression;
+    kind: SyntaxKind.SpreadAssignment;
+    expression: Expression;
+}
+export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment;
+export interface PropertyLikeDeclaration extends NamedDeclaration {
+    name: PropertyName;
+}
+export interface ObjectBindingPattern extends Node {
+    kind: SyntaxKind.ObjectBindingPattern;
+    parent: VariableDeclaration | ParameterDeclaration | BindingElement;
+    elements: NodeArray<BindingElement>;
+}
+export interface ArrayBindingPattern extends Node {
+    kind: SyntaxKind.ArrayBindingPattern;
+    parent: VariableDeclaration | ParameterDeclaration | BindingElement;
+    elements: NodeArray<ArrayBindingElement>;
+}
+export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
+export type ArrayBindingElement = BindingElement | OmittedExpression;
+/** A base dos nós que têm assinatura e corpo: na Linguagem, só a arrow. */
+export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
+    _functionLikeDeclarationBrand: any;
+    questionToken?: QuestionToken;
+    exclamationToken?: ExclamationToken;
+    body?: Block | Expression;
+    endFlowNode?: FlowNode;
+}
+export type FunctionLikeDeclaration = ArrowFunction;
+/** @deprecated Use SignatureDeclaration */
+export type FunctionLike = SignatureDeclaration;
+export interface MethodSignature extends SignatureDeclarationBase, TypeElement {
+    kind: SyntaxKind.MethodSignature;
+    parent: ObjectTypeDeclaration;
+    name: PropertyName;
+}
+export interface IndexSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
+    kind: SyntaxKind.IndexSignature;
+    parent: ObjectTypeDeclaration;
+}
+export interface TypeNode extends Node {
+    _typeNodeBrand: any;
+}
+export interface KeywordTypeNode extends TypeNode {
+    kind: SyntaxKind.AnyKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.NumberKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.VoidKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.NullKeyword | SyntaxKind.NeverKeyword;
+}
+export interface ImportTypeNode extends NodeWithTypeArguments {
+    kind: SyntaxKind.ImportType;
+    isTypeOf?: boolean;
+    argument: TypeNode;
+    qualifier?: EntityName;
+}
+export type LiteralImportTypeNode = ImportTypeNode & {
+    argument: LiteralTypeNode & {
+        literal: StringLiteral;
+    };
+};
+export interface FunctionTypeNode extends TypeNode, SignatureDeclarationBase {
+    kind: SyntaxKind.FunctionType;
+    type: TypeNode;
+}
+export interface NodeWithTypeArguments extends TypeNode {
+    typeArguments?: NodeArray<TypeNode>;
+}
+export type TypeReferenceType = TypeReferenceNode;
+export interface TypeReferenceNode extends NodeWithTypeArguments {
+    kind: SyntaxKind.TypeReference;
+    typeName: EntityName;
+}
+export interface TypePredicateNode extends TypeNode {
+    kind: SyntaxKind.TypePredicate;
+    parent: SignatureDeclaration;
+    assertsModifier?: AssertsToken;
+    parameterName: Identifier;
+    type?: TypeNode;
+}
+export interface TypeQueryNode extends TypeNode {
+    kind: SyntaxKind.TypeQuery;
+    exprName: EntityName;
+}
+export interface TypeLiteralNode extends TypeNode, Declaration {
+    kind: SyntaxKind.TypeLiteral;
+    members: NodeArray<TypeElement>;
+}
+export interface ArrayTypeNode extends TypeNode {
+    kind: SyntaxKind.ArrayType;
+    elementType: TypeNode;
+}
+export interface TupleTypeNode extends TypeNode {
+    kind: SyntaxKind.TupleType;
+    elementTypes: NodeArray<TypeNode>;
+}
+export interface OptionalTypeNode extends TypeNode {
+    kind: SyntaxKind.OptionalType;
+    type: TypeNode;
+}
+export interface RestTypeNode extends TypeNode {
+    kind: SyntaxKind.RestType;
+    type: TypeNode;
+}
+export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
+export interface UnionTypeNode extends TypeNode {
+    kind: SyntaxKind.UnionType;
+    types: NodeArray<TypeNode>;
+}
+export interface IntersectionTypeNode extends TypeNode {
+    kind: SyntaxKind.IntersectionType;
+    types: NodeArray<TypeNode>;
+}
+export interface ConditionalTypeNode extends TypeNode {
+    kind: SyntaxKind.ConditionalType;
+    checkType: TypeNode;
+    extendsType: TypeNode;
+    trueType: TypeNode;
+    falseType: TypeNode;
+}
+export interface InferTypeNode extends TypeNode {
+    kind: SyntaxKind.InferType;
+    typeParameter: TypeParameterDeclaration;
+}
+export interface ParenthesizedTypeNode extends TypeNode {
+    kind: SyntaxKind.ParenthesizedType;
+    type: TypeNode;
+}
+export interface TypeOperatorNode extends TypeNode {
+    kind: SyntaxKind.TypeOperator;
+    operator: SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword;
+    type: TypeNode;
+}
+export interface IndexedAccessTypeNode extends TypeNode {
+    kind: SyntaxKind.IndexedAccessType;
+    objectType: TypeNode;
+    indexType: TypeNode;
+}
+export interface MappedTypeNode extends TypeNode, Declaration {
+    kind: SyntaxKind.MappedType;
+    readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
+    typeParameter: TypeParameterDeclaration;
+    questionToken?: QuestionToken | PlusToken | MinusToken;
+    type?: TypeNode;
+}
+export interface LiteralTypeNode extends TypeNode {
+    kind: SyntaxKind.LiteralType;
+    literal: BooleanLiteral | LiteralExpression | PrefixUnaryExpression;
+}
+export interface StringLiteral extends LiteralExpression, Declaration {
+    kind: SyntaxKind.StringLiteral;
+    textSourceNode?: Identifier | StringLiteralLike | NumericLiteral;
+    /** Note: this is only set when synthesizing a node, not during parsing. */
+    singleQuote?: boolean;
+}
+export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
+export interface Expression extends Node {
+    _expressionBrand: any;
+}
+export interface OmittedExpression extends Expression {
+    kind: SyntaxKind.OmittedExpression;
+}
+export interface PartiallyEmittedExpression extends LeftHandSideExpression {
+    kind: SyntaxKind.PartiallyEmittedExpression;
+    expression: Expression;
+}
+export interface UnaryExpression extends Expression {
+    _unaryExpressionBrand: any;
+}
+/** Deprecated, please use UpdateExpression */
+export type IncrementExpression = UpdateExpression;
+export interface UpdateExpression extends UnaryExpression {
+    _updateExpressionBrand: any;
+}
+export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
+export interface PrefixUnaryExpression extends UpdateExpression {
+    kind: SyntaxKind.PrefixUnaryExpression;
+    operator: PrefixUnaryOperator;
+    operand: UnaryExpression;
+}
+export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;
+export interface PostfixUnaryExpression extends UpdateExpression {
+    kind: SyntaxKind.PostfixUnaryExpression;
+    operand: LeftHandSideExpression;
+    operator: PostfixUnaryOperator;
+}
+export interface LeftHandSideExpression extends UpdateExpression {
+    _leftHandSideExpressionBrand: any;
+}
+export interface MemberExpression extends LeftHandSideExpression {
+    _memberExpressionBrand: any;
+}
+export interface PrimaryExpression extends MemberExpression {
+    _primaryExpressionBrand: any;
+}
+export interface NullLiteral extends PrimaryExpression, TypeNode {
+    kind: SyntaxKind.NullKeyword;
+}
+export interface BooleanLiteral extends PrimaryExpression, TypeNode {
+    kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword;
+}
+export interface ImportExpression extends PrimaryExpression {
+    kind: SyntaxKind.ImportKeyword;
+}
+export interface DeleteExpression extends UnaryExpression {
+    kind: SyntaxKind.DeleteExpression;
+    expression: UnaryExpression;
+}
+export interface TypeOfExpression extends UnaryExpression {
+    kind: SyntaxKind.TypeOfExpression;
+    expression: UnaryExpression;
+}
+export interface AwaitExpression extends UnaryExpression {
+    kind: SyntaxKind.AwaitExpression;
+    expression: UnaryExpression;
+}
+export type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
+export type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;
+export type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;
+export type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken;
+export type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator;
+export type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
+export type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;
+export type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InKeyword;
+export type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator;
+export type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken;
+export type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator;
+export type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken;
+export type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator;
+export type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken;
+export type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;
+export type CompoundAssignmentOperator = SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken;
+export type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;
+export type AssignmentOperatorOrHigher = SyntaxKind.QuestionQuestionToken | LogicalOperatorOrHigher | AssignmentOperator;
+export type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;
+export type BinaryOperatorToken = Token<BinaryOperator>;
+export interface BinaryExpression extends Expression, Declaration {
+    kind: SyntaxKind.BinaryExpression;
+    left: Expression;
+    operatorToken: BinaryOperatorToken;
+    right: Expression;
+}
+export type AssignmentOperatorToken = Token<AssignmentOperator>;
+export interface AssignmentExpression<TOperator extends AssignmentOperatorToken> extends BinaryExpression {
+    left: LeftHandSideExpression;
+    operatorToken: TOperator;
+}
+export interface ObjectDestructuringAssignment extends AssignmentExpression<EqualsToken> {
+    left: ObjectLiteralExpression;
+}
+export interface ArrayDestructuringAssignment extends AssignmentExpression<EqualsToken> {
+    left: ArrayLiteralExpression;
+}
+export type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment;
+export type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression<EqualsToken> | Identifier | PropertyAccessExpression | ElementAccessExpression;
+export type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment;
+export type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Identifier | PropertyAccessExpression | ElementAccessExpression | OmittedExpression;
+export type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression;
+export type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression;
+export type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression;
+export type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern;
+export interface ConditionalExpression extends Expression {
+    kind: SyntaxKind.ConditionalExpression;
+    condition: Expression;
+    questionToken: QuestionToken;
+    whenTrue: Expression;
+    colonToken: ColonToken;
+    whenFalse: Expression;
+}
+export type FunctionBody = Block;
+export type ConciseBody = FunctionBody | Expression;
+export interface ArrowFunction extends Expression, FunctionLikeDeclarationBase {
+    kind: SyntaxKind.ArrowFunction;
+    equalsGreaterThanToken: EqualsGreaterThanToken;
+    body: ConciseBody;
+    name: never;
+}
+export interface LiteralLikeNode extends Node {
+    text: string;
+    isUnterminated?: boolean;
+    hasExtendedUnicodeEscape?: boolean;
+}
+export interface TemplateLiteralLikeNode extends LiteralLikeNode {
+    rawText?: string;
+}
+export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
+    _literalExpressionBrand: any;
+}
+export interface NoSubstitutionTemplateLiteral extends LiteralExpression, TemplateLiteralLikeNode, Declaration {
+    kind: SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export declare enum TokenFlags {
+    None = 0,
+    PrecedingLineBreak = 1,
+    Unterminated = 4,
+    ExtendedUnicodeEscape = 8,
+    Scientific = 16,// e.g. `10e2`
+    Octal = 32,// e.g. `0777`
+    HexSpecifier = 64,// e.g. `0x00000000`
+    BinarySpecifier = 128,// e.g. `0b0110010000000000`
+    OctalSpecifier = 256,// e.g. `0o777`
+    ContainsSeparator = 512,// e.g. `0b1100_0101`
+    UnicodeEscape = 1024,
+    BinaryOrOctalSpecifier = 384,
+    NumericLiteralFlags = 1008
+}
+export interface NumericLiteral extends LiteralExpression, Declaration {
+    kind: SyntaxKind.NumericLiteral;
+    numericLiteralFlags: TokenFlags;
+}
+export interface BigIntLiteral extends LiteralExpression {
+    kind: SyntaxKind.BigIntLiteral;
+}
+export interface TemplateHead extends TemplateLiteralLikeNode {
+    kind: SyntaxKind.TemplateHead;
+    parent: TemplateExpression;
+}
+export interface TemplateMiddle extends TemplateLiteralLikeNode {
+    kind: SyntaxKind.TemplateMiddle;
+    parent: TemplateSpan;
+}
+export interface TemplateTail extends TemplateLiteralLikeNode {
+    kind: SyntaxKind.TemplateTail;
+    parent: TemplateSpan;
+}
+export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;
+export interface TemplateExpression extends PrimaryExpression {
+    kind: SyntaxKind.TemplateExpression;
+    head: TemplateHead;
+    templateSpans: NodeArray<TemplateSpan>;
+}
+export interface TemplateSpan extends Node {
+    kind: SyntaxKind.TemplateSpan;
+    parent: TemplateExpression;
+    expression: Expression;
+    literal: TemplateMiddle | TemplateTail;
+}
+export interface ParenthesizedExpression extends PrimaryExpression {
+    kind: SyntaxKind.ParenthesizedExpression;
+    expression: Expression;
+}
+export interface ArrayLiteralExpression extends PrimaryExpression {
+    kind: SyntaxKind.ArrayLiteralExpression;
+    elements: NodeArray<Expression>;
+    multiLine?: boolean;
+}
+export interface SpreadElement extends Expression {
+    kind: SyntaxKind.SpreadElement;
+    parent: ArrayLiteralExpression | CallExpression;
+    expression: Expression;
+}
+/**
+ * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to
+ * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be
+ * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type
+ * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
+ */
+export interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
+    properties: NodeArray<T>;
+}
+export interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike> {
+    kind: SyntaxKind.ObjectLiteralExpression;
+    multiLine?: boolean;
+}
+export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
+export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
+export type AccessExpression = PropertyAccessExpression | ElementAccessExpression;
+export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
+    kind: SyntaxKind.PropertyAccessExpression;
+    expression: LeftHandSideExpression;
+    questionDotToken?: QuestionDotToken;
+    name: Identifier;
+}
+export interface PropertyAccessChain extends PropertyAccessExpression {
+    _optionalChainBrand: any;
+    name: Identifier;
+}
+export interface PropertyAccessChainRoot extends PropertyAccessChain {
+    questionDotToken: QuestionDotToken;
+}
+/** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
+export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
+    _propertyAccessExpressionLikeQualifiedNameBrand?: any;
+    expression: EntityNameExpression;
+    name: Identifier;
+}
+export interface ElementAccessExpression extends MemberExpression {
+    kind: SyntaxKind.ElementAccessExpression;
+    expression: LeftHandSideExpression;
+    questionDotToken?: QuestionDotToken;
+    argumentExpression: Expression;
+}
+export interface ElementAccessChain extends ElementAccessExpression {
+    _optionalChainBrand: any;
+}
+export interface ElementAccessChainRoot extends ElementAccessChain {
+    questionDotToken: QuestionDotToken;
+}
+export interface CallExpression extends LeftHandSideExpression, Declaration {
+    kind: SyntaxKind.CallExpression;
+    expression: LeftHandSideExpression;
+    questionDotToken?: QuestionDotToken;
+    typeArguments?: NodeArray<TypeNode>;
+    arguments: NodeArray<Expression>;
+}
+export interface CallChain extends CallExpression {
+    _optionalChainBrand: any;
+}
+export interface CallChainRoot extends CallChain {
+    questionDotToken: QuestionDotToken;
+}
+export type OptionalChain = PropertyAccessChain | ElementAccessChain | CallChain;
+export type OptionalChainRoot = PropertyAccessChainRoot | ElementAccessChainRoot | CallChainRoot;
+export interface WellKnownSymbolExpression extends PropertyAccessExpression {
+    expression: Identifier & {
+        escapedText: "Symbol";
+    };
+    name: Identifier;
+}
+export type BindableObjectDefinePropertyCall = CallExpression & {
+    arguments: {
+        0: BindableStaticNameExpression;
+        1: StringLiteralLike | NumericLiteral;
+        2: ObjectLiteralExpression;
+    };
+};
+export type BindableStaticNameExpression = EntityNameExpression | BindableStaticElementAccessExpression;
+export type LiteralLikeElementAccessExpression = ElementAccessExpression & Declaration & {
+    argumentExpression: StringLiteralLike | NumericLiteral | WellKnownSymbolExpression;
+};
+export type BindableStaticElementAccessExpression = LiteralLikeElementAccessExpression & {
+    expression: BindableStaticNameExpression;
+};
+export type BindableStaticAccessExpression = PropertyAccessEntityNameExpression | BindableStaticElementAccessExpression;
+export interface ImportCall extends CallExpression {
+    expression: ImportExpression;
+}
+export type CallLikeExpression = CallExpression | JsxOpeningLikeElement;
+export interface AsExpression extends Expression {
+    kind: SyntaxKind.AsExpression;
+    expression: Expression;
+    type: TypeNode;
+}
+export type AssertionExpression = AsExpression;
+export interface MetaProperty extends PrimaryExpression {
+    kind: SyntaxKind.MetaProperty;
+    keywordToken: SyntaxKind.ImportKeyword;
+    name: Identifier;
+}
+export interface ImportMetaProperty extends MetaProperty {
+    keywordToken: SyntaxKind.ImportKeyword;
+    name: Identifier & {
+        escapedText: __String & "meta";
+    };
+}
+export interface JsxElement extends PrimaryExpression {
+    kind: SyntaxKind.JsxElement;
+    openingElement: JsxOpeningElement;
+    children: NodeArray<JsxChild>;
+    closingElement: JsxClosingElement;
+}
+export type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
+export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
+export type JsxTagNameExpression = Identifier | JsxTagNamePropertyAccess;
+export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
+    expression: JsxTagNameExpression;
+}
+export interface JsxAttributes extends ObjectLiteralExpressionBase<JsxAttributeLike> {
+    kind: SyntaxKind.JsxAttributes;
+    parent: JsxOpeningLikeElement;
+}
+export interface JsxOpeningElement extends Expression {
+    kind: SyntaxKind.JsxOpeningElement;
+    parent: JsxElement;
+    tagName: JsxTagNameExpression;
+    typeArguments?: NodeArray<TypeNode>;
+    attributes: JsxAttributes;
+}
+export interface JsxSelfClosingElement extends PrimaryExpression {
+    kind: SyntaxKind.JsxSelfClosingElement;
+    tagName: JsxTagNameExpression;
+    typeArguments?: NodeArray<TypeNode>;
+    attributes: JsxAttributes;
+}
+export interface JsxFragment extends PrimaryExpression {
+    kind: SyntaxKind.JsxFragment;
+    openingFragment: JsxOpeningFragment;
+    children: NodeArray<JsxChild>;
+    closingFragment: JsxClosingFragment;
+}
+export interface JsxOpeningFragment extends Expression {
+    kind: SyntaxKind.JsxOpeningFragment;
+    parent: JsxFragment;
+}
+export interface JsxClosingFragment extends Expression {
+    kind: SyntaxKind.JsxClosingFragment;
+    parent: JsxFragment;
+}
+export interface JsxAttribute extends ObjectLiteralElement {
+    kind: SyntaxKind.JsxAttribute;
+    parent: JsxAttributes;
+    name: Identifier;
+    initializer?: StringLiteral | JsxExpression;
+}
+export interface JsxSpreadAttribute extends ObjectLiteralElement {
+    kind: SyntaxKind.JsxSpreadAttribute;
+    parent: JsxAttributes;
+    expression: Expression;
+}
+export interface JsxClosingElement extends Node {
+    kind: SyntaxKind.JsxClosingElement;
+    parent: JsxElement;
+    tagName: JsxTagNameExpression;
+}
+export interface JsxExpression extends Expression {
+    kind: SyntaxKind.JsxExpression;
+    parent: JsxElement | JsxAttributeLike;
+    dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
+    expression?: Expression;
+}
+export interface JsxText extends LiteralLikeNode {
+    kind: SyntaxKind.JsxText;
+    containsOnlyTriviaWhiteSpaces: boolean;
+    parent: JsxElement;
+}
+export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
+export interface Statement extends Node {
+    _statementBrand: any;
+}
+export interface NotEmittedStatement extends Statement {
+    kind: SyntaxKind.NotEmittedStatement;
+}
+/**
+ * Marks the end of transformed declaration to properly emit exports.
+ */
+export interface EndOfDeclarationMarker extends Statement {
+    kind: SyntaxKind.EndOfDeclarationMarker;
+}
+/**
+ * A list of comma-separated expressions. This node is only created by transformations.
+ */
+export interface CommaListExpression extends Expression {
+    kind: SyntaxKind.CommaListExpression;
+    elements: NodeArray<Expression>;
+}
+/**
+ * Marks the beginning of a merged transformed declaration.
+ */
+export interface MergeDeclarationMarker extends Statement {
+    kind: SyntaxKind.MergeDeclarationMarker;
+}
+export interface SyntheticReferenceExpression extends LeftHandSideExpression {
+    kind: SyntaxKind.SyntheticReferenceExpression;
+    expression: Expression;
+    thisArg: Expression;
+}
+export interface EmptyStatement extends Statement {
+    kind: SyntaxKind.EmptyStatement;
+}
+export interface MissingDeclaration extends DeclarationStatement {
+    kind: SyntaxKind.MissingDeclaration;
+    name?: Identifier;
+}
+export type BlockLike = SourceFile | Block | ModuleBlock | CaseOrDefaultClause;
+export interface Block extends Statement {
+    kind: SyntaxKind.Block;
+    statements: NodeArray<Statement>;
+    multiLine?: boolean;
+}
+export interface VariableStatement extends Statement {
+    kind: SyntaxKind.VariableStatement;
+    declarationList: VariableDeclarationList;
+}
+export interface ExpressionStatement extends Statement {
+    kind: SyntaxKind.ExpressionStatement;
+    expression: Expression;
+}
+export interface PrologueDirective extends ExpressionStatement {
+    expression: StringLiteral;
+}
+export interface IfStatement extends Statement {
+    kind: SyntaxKind.IfStatement;
+    expression: Expression;
+    thenStatement: Statement;
+    elseStatement?: Statement;
+}
+export interface IterationStatement extends Statement {
+    statement: Statement;
+}
+export interface DoStatement extends IterationStatement {
+    kind: SyntaxKind.DoStatement;
+    expression: Expression;
+}
+export interface WhileStatement extends IterationStatement {
+    kind: SyntaxKind.WhileStatement;
+    expression: Expression;
+}
+export type ForInitializer = VariableDeclarationList | Expression;
+export interface ForStatement extends IterationStatement {
+    kind: SyntaxKind.ForStatement;
+    initializer?: ForInitializer;
+    condition?: Expression;
+    incrementor?: Expression;
+}
+export type ForInOrOfStatement = ForInStatement | ForOfStatement;
+export interface ForInStatement extends IterationStatement {
+    kind: SyntaxKind.ForInStatement;
+    initializer: ForInitializer;
+    expression: Expression;
+}
+export interface ForOfStatement extends IterationStatement {
+    kind: SyntaxKind.ForOfStatement;
+    awaitModifier?: AwaitKeywordToken;
+    initializer: ForInitializer;
+    expression: Expression;
+}
+export interface BreakStatement extends Statement {
+    kind: SyntaxKind.BreakStatement;
+}
+export interface ContinueStatement extends Statement {
+    kind: SyntaxKind.ContinueStatement;
+}
+export type BreakOrContinueStatement = BreakStatement | ContinueStatement;
+export interface ReturnStatement extends Statement {
+    kind: SyntaxKind.ReturnStatement;
+    expression?: Expression;
+}
+export interface SwitchStatement extends Statement {
+    kind: SyntaxKind.SwitchStatement;
+    expression: Expression;
+    caseBlock: CaseBlock;
+    possiblyExhaustive?: boolean;
+}
+export interface CaseBlock extends Node {
+    kind: SyntaxKind.CaseBlock;
+    parent: SwitchStatement;
+    clauses: NodeArray<CaseOrDefaultClause>;
+}
+export interface CaseClause extends Node {
+    kind: SyntaxKind.CaseClause;
+    parent: CaseBlock;
+    expression: Expression;
+    statements: NodeArray<Statement>;
+    fallthroughFlowNode?: FlowNode;
+}
+export interface DefaultClause extends Node {
+    kind: SyntaxKind.DefaultClause;
+    parent: CaseBlock;
+    statements: NodeArray<Statement>;
+    fallthroughFlowNode?: FlowNode;
+}
+export type CaseOrDefaultClause = CaseClause | DefaultClause;
+export interface ThrowStatement extends Statement {
+    kind: SyntaxKind.ThrowStatement;
+    expression?: Expression;
+}
+export interface TryStatement extends Statement {
+    kind: SyntaxKind.TryStatement;
+    tryBlock: Block;
+    catchClause?: CatchClause;
+    finallyBlock?: Block;
+}
+export interface CatchClause extends Node {
+    kind: SyntaxKind.CatchClause;
+    parent: TryStatement;
+    variableDeclaration?: VariableDeclaration;
+    block: Block;
+}
+export type ObjectTypeDeclaration = TypeLiteralNode;
+export type DeclarationWithTypeParameters = DeclarationWithTypeParameterChildren;
+export type DeclarationWithTypeParameterChildren = SignatureDeclaration | TypeAliasDeclaration;
+export interface TypeElement extends NamedDeclaration {
+    _typeElementBrand: any;
+    name?: PropertyName;
+    questionToken?: QuestionToken;
+}
+export interface TypeAliasDeclaration extends DeclarationStatement {
+    kind: SyntaxKind.TypeAliasDeclaration;
+    name: Identifier;
+    typeParameters?: NodeArray<TypeParameterDeclaration>;
+    type: TypeNode;
+}
+export type ModuleName = Identifier;
+export type ModuleBody = NamespaceBody;
+export interface AmbientModuleDeclaration extends ModuleDeclaration {
+    body?: ModuleBlock;
+}
+export interface ModuleDeclaration extends DeclarationStatement {
+    kind: SyntaxKind.ModuleDeclaration;
+    parent: ModuleBody | SourceFile;
+    name: ModuleName;
+    body?: ModuleBody;
+}
+export type NamespaceBody = ModuleBlock | NamespaceDeclaration;
+export interface NamespaceDeclaration extends ModuleDeclaration {
+    name: Identifier;
+    body: NamespaceBody;
+}
+export interface ModuleBlock extends Node, Statement {
+    kind: SyntaxKind.ModuleBlock;
+    parent: ModuleDeclaration;
+    statements: NodeArray<Statement>;
+}
+export interface ImportDeclaration extends Statement {
+    kind: SyntaxKind.ImportDeclaration;
+    parent: SourceFile | ModuleBlock;
+    importClause?: ImportClause;
+    /** If this is not a StringLiteral it will be a grammar error. */
+    moduleSpecifier: Expression;
+}
+export type NamedImportBindings = NamespaceImport | NamedImports;
+export type NamedExportBindings = NamespaceExport | NamedExports;
+export interface ImportClause extends NamedDeclaration {
+    kind: SyntaxKind.ImportClause;
+    parent: ImportDeclaration;
+    isTypeOnly: boolean;
+    name?: Identifier;
+    namedBindings?: NamedImportBindings;
+}
+export interface NamespaceImport extends NamedDeclaration {
+    kind: SyntaxKind.NamespaceImport;
+    parent: ImportClause;
+    name: Identifier;
+}
+export interface NamespaceExport extends NamedDeclaration {
+    kind: SyntaxKind.NamespaceExport;
+    parent: ExportDeclaration;
+    name: Identifier;
+}
+export interface ExportDeclaration extends DeclarationStatement {
+    kind: SyntaxKind.ExportDeclaration;
+    parent: SourceFile | ModuleBlock;
+    isTypeOnly: boolean;
+    /** Will not be assigned in the case of `export * from "foo";` */
+    exportClause?: NamedExportBindings;
+    /** If this is not a StringLiteral it will be a grammar error. */
+    moduleSpecifier?: Expression;
+}
+export interface NamedImports extends Node {
+    kind: SyntaxKind.NamedImports;
+    parent: ImportClause;
+    elements: NodeArray<ImportSpecifier>;
+}
+export interface NamedExports extends Node {
+    kind: SyntaxKind.NamedExports;
+    parent: ExportDeclaration;
+    elements: NodeArray<ExportSpecifier>;
+}
+export type NamedImportsOrExports = NamedImports | NamedExports;
+export interface ImportSpecifier extends NamedDeclaration {
+    kind: SyntaxKind.ImportSpecifier;
+    parent: NamedImports;
+    propertyName?: Identifier;
+    name: Identifier;
+}
+export interface ExportSpecifier extends NamedDeclaration {
+    kind: SyntaxKind.ExportSpecifier;
+    parent: NamedExports;
+    propertyName?: Identifier;
+    name: Identifier;
+}
+export type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
+export type TypeOnlyCompatibleAliasDeclaration = ImportClause | NamespaceImport | ImportOrExportSpecifier;
+/** O `export default` de uma expressão. */
+export interface ExportAssignment extends DeclarationStatement {
+    kind: SyntaxKind.ExportAssignment;
+    parent: SourceFile;
+    expression: Expression;
+}
+export interface FileReference extends TextRange {
+    fileName: string;
+}
+export interface CheckJsDirective extends TextRange {
+    enabled: boolean;
+}
+export type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia;
+export interface CommentRange extends TextRange {
+    hasTrailingNewLine?: boolean;
+    kind: CommentKind;
+}
+export interface SynthesizedComment extends CommentRange {
+    text: string;
+    pos: -1;
+    end: -1;
+}
+export declare enum FlowFlags {
+    Unreachable = 1,// Unreachable code
+    Start = 2,// Start of flow graph
+    BranchLabel = 4,// Non-looping junction
+    LoopLabel = 8,// Looping junction
+    Assignment = 16,// Assignment
+    TrueCondition = 32,// Condition known to be true
+    FalseCondition = 64,// Condition known to be false
+    SwitchClause = 128,// Switch statement clause
+    ArrayMutation = 256,// Potential array mutation
+    Call = 512,// Potential assertion call
+    ReduceLabel = 1024,// Temporarily reduce antecedents of label
+    Referenced = 2048,// Referenced as antecedent once
+    Shared = 4096,// Referenced as antecedent more than once
+    Label = 12,
+    Condition = 96
+}
+export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation;
+export interface FlowNodeBase {
+    flags: FlowFlags;
+    id?: number;
+}
+export interface FlowLock {
+    locked?: boolean;
+}
+export interface AfterFinallyFlow extends FlowNodeBase, FlowLock {
+    antecedent: FlowNode;
+}
+export interface PreFinallyFlow extends FlowNodeBase {
+    antecedent: FlowNode;
+    lock: FlowLock;
+}
+export interface FlowStart extends FlowNodeBase {
+    node?: ArrowFunction;
+}
+export interface FlowLabel extends FlowNodeBase {
+    antecedents: FlowNode[] | undefined;
+}
+export interface FlowAssignment extends FlowNodeBase {
+    node: Expression | VariableDeclaration | BindingElement;
+    antecedent: FlowNode;
+}
+export interface FlowCall extends FlowNodeBase {
+    node: CallExpression;
+    antecedent: FlowNode;
+}
+export interface FlowCondition extends FlowNodeBase {
+    node: Expression;
+    antecedent: FlowNode;
+}
+export interface FlowSwitchClause extends FlowNodeBase {
+    switchStatement: SwitchStatement;
+    clauseStart: number;
+    clauseEnd: number;
+    antecedent: FlowNode;
+}
+export interface FlowArrayMutation extends FlowNodeBase {
+    node: CallExpression | BinaryExpression;
+    antecedent: FlowNode;
+}
+export interface FlowReduceLabel extends FlowNodeBase {
+    target: FlowLabel;
+    antecedents: FlowNode[];
+    antecedent: FlowNode;
+}
+export interface AmdDependency {
+    path: string;
+    name?: string;
+}
+/**
+ * Subset of properties from SourceFile that are used in multiple utility functions
+ */
+export interface SourceFileLike {
+    readonly text: string;
+    lineMap?: readonly number[];
+    getPositionOfLineAndCharacter?(line: number, character: number, allowEdits?: true): number;
+}
+export interface SourceFile extends Declaration {
+    kind: SyntaxKind.SourceFile;
+    statements: NodeArray<Statement>;
+    endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
+    fileName: string;
+    path: Path;
+    text: string;
+    /** Resolved path can be different from path property,
+     * when file is included through project reference is mapped to its output instead of source
+     * in that case resolvedPath = path to output file
+     * path = input file's path
+     */
+    resolvedPath: Path;
+    /** Original file name that can be different from fileName,
+     * when file is included through project reference is mapped to its output instead of source
+     * in that case originalFileName = name of input file
+     * fileName = output file's name
+     */
+    originalFileName: string;
+    amdDependencies: readonly AmdDependency[];
+    moduleName?: string;
+    referencedFiles: readonly FileReference[];
+    typeReferenceDirectives: readonly FileReference[];
+    libReferenceDirectives: readonly FileReference[];
+    languageVariant: LanguageVariant;
+    isDeclarationFile: boolean;
+    renamedDependencies?: ReadonlyMap<string>;
+    /**
+     * lib.d.ts should have a reference comment like
+     *
+     *  /// <reference no-default-lib="true"/>
+     *
+     * If any other file has this comment, it signals not to include lib.d.ts
+     * because this containing file is intended to act as a default library.
+     */
+    hasNoDefaultLib: boolean;
+    languageVersion: ScriptTarget;
+    scriptKind: ScriptKind;
+    /**
+     * The first "most obvious" node that makes a file an external module.
+     * This is intended to be the first top-level import/export,
+     * but could be arbitrarily nested (e.g. `import.meta`).
+     */
+    externalModuleIndicator?: Node;
+    commonJsModuleIndicator?: Node;
+    identifiers: Map<string>;
+    parseDiagnostics: DiagnosticWithLocation[];
+    bindDiagnostics: DiagnosticWithLocation[];
+    bindSuggestionDiagnostics?: DiagnosticWithLocation[];
+    additionalSyntacticDiagnostics?: readonly DiagnosticWithLocation[];
+    lineMap: readonly number[];
+    classifiableNames?: ReadonlyUnderscoreEscapedMap<true>;
+    commentDirectives?: CommentDirective[];
+    resolvedModules?: Map<ResolvedModuleFull | undefined>;
+    imports: readonly StringLiteralLike[];
+    moduleAugmentations: readonly Identifier[];
+    ambientModuleNames: readonly string[];
+    checkJsDirective?: CheckJsDirective;
+    version: string;
+    pragmas: ReadonlyPragmaMap;
+    exportedModulesFromDeclarationEmit?: ExportedModulesFromDeclarationEmit;
+}
+export interface CommentDirective {
+    range: TextRange;
+    type: CommentDirectiveType;
+}
+export declare enum CommentDirectiveType {
+    ExpectError = 0,
+    Ignore = 1
+}
+export type ExportedModulesFromDeclarationEmit = readonly Symbol[];
+export interface Bundle extends Node {
+    kind: SyntaxKind.Bundle;
+    prepends: readonly (InputFiles | UnparsedSource)[];
+    sourceFiles: readonly SourceFile[];
+    syntheticFileReferences?: readonly FileReference[];
+    syntheticTypeReferences?: readonly FileReference[];
+    syntheticLibReferences?: readonly FileReference[];
+    hasNoDefaultLib?: boolean;
+}
+export interface InputFiles extends Node {
+    kind: SyntaxKind.InputFiles;
+    javascriptPath?: string;
+    javascriptText: string;
+    javascriptMapPath?: string;
+    javascriptMapText?: string;
+    declarationPath?: string;
+    declarationText: string;
+    declarationMapPath?: string;
+    declarationMapText?: string;
+    buildInfoPath?: string;
+    buildInfo?: BuildInfo;
+    oldFileOfCurrentEmit?: boolean;
+}
+export interface UnparsedSource extends Node {
+    kind: SyntaxKind.UnparsedSource;
+    fileName: string;
+    text: string;
+    prologues: readonly UnparsedPrologue[];
+    helpers: readonly UnscopedEmitHelper[] | undefined;
+    referencedFiles: readonly FileReference[];
+    typeReferenceDirectives: readonly string[] | undefined;
+    libReferenceDirectives: readonly FileReference[];
+    hasNoDefaultLib?: boolean;
+    sourceMapPath?: string;
+    sourceMapText?: string;
+    syntheticReferences?: readonly UnparsedSyntheticReference[];
+    texts: readonly UnparsedSourceText[];
+    oldFileOfCurrentEmit?: boolean;
+    parsedSourceMap?: RawSourceMap | false | undefined;
+    getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
+}
+export type UnparsedSourceText = UnparsedPrepend | UnparsedTextLike;
+export type UnparsedNode = UnparsedPrologue | UnparsedSourceText | UnparsedSyntheticReference;
+export interface UnparsedSection extends Node {
+    kind: SyntaxKind;
+    data?: string;
+    parent: UnparsedSource;
+}
+export interface UnparsedPrologue extends UnparsedSection {
+    kind: SyntaxKind.UnparsedPrologue;
+    data: string;
+    parent: UnparsedSource;
+}
+export interface UnparsedPrepend extends UnparsedSection {
+    kind: SyntaxKind.UnparsedPrepend;
+    data: string;
+    parent: UnparsedSource;
+    texts: readonly UnparsedTextLike[];
+}
+export interface UnparsedTextLike extends UnparsedSection {
+    kind: SyntaxKind.UnparsedText | SyntaxKind.UnparsedInternalText;
+    parent: UnparsedSource;
+}
+export interface UnparsedSyntheticReference extends UnparsedSection {
+    kind: SyntaxKind.UnparsedSyntheticReference;
+    parent: UnparsedSource;
+    section: BundleFileHasNoDefaultLib | BundleFileReference;
+}
+export interface JsonSourceFile extends SourceFile {
+    statements: NodeArray<JsonObjectExpressionStatement>;
+}
+export interface TsConfigSourceFile extends JsonSourceFile {
+    extendedSourceFiles?: string[];
+}
+export interface JsonMinusNumericLiteral extends PrefixUnaryExpression {
+    kind: SyntaxKind.PrefixUnaryExpression;
+    operator: SyntaxKind.MinusToken;
+    operand: NumericLiteral;
+}
+export interface JsonObjectExpressionStatement extends ExpressionStatement {
+    expression: ObjectLiteralExpression | ArrayLiteralExpression | JsonMinusNumericLiteral | NumericLiteral | StringLiteral | BooleanLiteral | NullLiteral;
+}
+export interface CustomTransformer {
+    transformSourceFile(node: SourceFile): SourceFile;
+    transformBundle(node: Bundle): Bundle;
+}
+/** Return code used by getEmitOutput function to indicate status of the function */
+export declare enum ExitStatus {
+    Success = 0,
+    DiagnosticsPresent_OutputsSkipped = 1,
+    DiagnosticsPresent_OutputsGenerated = 2,
+    InvalidProject_OutputsSkipped = 3,
+    ProjectReferenceCycle_OutputsSkipped = 4,
+    /** @deprecated Use ProjectReferenceCycle_OutputsSkipped instead. */
+    ProjectReferenceCycle_OutputsSkupped = 4
+}
+export declare enum SyntheticSymbolKind {
+    UnionOrIntersection = 0,
+    Spread = 1
+}
+export type AnyImportSyntax = ImportDeclaration;
+export type AnyImportOrReExport = AnyImportSyntax | ExportDeclaration;
+export interface ValidImportTypeNode extends ImportTypeNode {
+    argument: LiteralTypeNode & {
+        literal: StringLiteral;
+    };
+}
+/** Na tag, também o `import =` de `require` (CK-03). */
+export type AnyValidImportOrReExport = (ImportDeclaration | ExportDeclaration) & {
+    moduleSpecifier: StringLiteral;
+} | RequireOrImportCall | ValidImportTypeNode;
+export type RequireOrImportCall = CallExpression & {
+    expression: Identifier;
+    arguments: [StringLiteralLike];
+};
+export type LateVisibilityPaintedStatement = AnyImportSyntax | VariableStatement | ModuleDeclaration | TypeAliasDeclaration;
+export declare enum SymbolFlags {
+    None = 0,
+    FunctionScopedVariable = 1,// Variable (var) or parameter
+    BlockScopedVariable = 2,// A block-scoped variable (let or const)
+    Property = 4,// Property
+    Function = 16,// Function
+    Interface = 64,// Interface
+    ValueModule = 512,// Instantiated module
+    NamespaceModule = 1024,// Uninstantiated module
+    TypeLiteral = 2048,// Type Literal or mapped type
+    ObjectLiteral = 4096,// Object Literal
+    Method = 8192,// Method
+    Signature = 131072,// Call or index signature
+    TypeParameter = 262144,// Type parameter
+    TypeAlias = 524288,// Type alias
+    ExportValue = 1048576,// Exported value marker (see comment in declareModuleMember in binder)
+    Alias = 2097152,// An alias for another symbol (see comment in isAliasSymbolDeclaration in checker)
+    ExportStar = 8388608,// Export * declaration
+    Optional = 16777216,// Optional property
+    Transient = 33554432,// Transient symbol (created during type check)
+    Assignment = 67108864,// Assignment treated as declaration (eg `this.prop = 1`)
+    ModuleExports = 134217728,// Symbol for CommonJS `module` of `module.exports`
+    All = 62799447,
+    Variable = 3,
+    Value = 12823,
+    Type = 788544,
+    Namespace = 1536,
+    Module = 1536,
+    BlockScopedVariableExcludes = 12823,
+    ParameterExcludes = 12823,
+    PropertyExcludes = 0,
+    FunctionExcludes = 12295,
+    ValueModuleExcludes = 12295,
+    NamespaceModuleExcludes = 0,
+    TypeParameterExcludes = 526400,
+    TypeAliasExcludes = 788544,
+    AliasExcludes = 2097152,
+    ModuleMember = 2623059,
+    ExportHasLocal = 528,
+    BlockScoped = 2,
+    ClassMember = 8196,
+    Classifiable = 2885184,
+    LateBindingContainer = 6224
+}
+export interface Symbol {
+    flags: SymbolFlags;
+    escapedName: __String;
+    declarations: Declaration[];
+    valueDeclaration: Declaration;
+    members?: SymbolTable;
+    exports?: SymbolTable;
+    id?: number;
+    mergeId?: number;
+    parent?: Symbol;
+    exportSymbol?: Symbol;
+    isReferenced?: SymbolFlags;
+    isAssigned?: boolean;
+}
+export declare enum InternalSymbolName {
+    Call = "__call",// Call signatures
+    Index = "__index",// Index signatures
+    ExportStar = "__export",// Module export * declarations
+    Global = "__global",// Global self-reference
+    Missing = "__missing",// Indicates missing symbol
+    Type = "__type",// Anonymous type literal symbol
+    Object = "__object",// Anonymous object literal declaration
+    JSXAttributes = "__jsxAttributes",// Anonymous JSX attributes object literal declaration
+    Function = "__function",// Unnamed function expression
+    Computed = "__computed",// Computed property name declaration with dynamic name
+    Resolving = "__resolving__",// Indicator symbol used to mark partially resolved type aliases
+    Default = "default"
+}
+/**
+ * This represents a string whose leading underscore have been escaped by adding extra leading underscores.
+ * The shape of this brand is rather unique compared to others we've used.
+ * Instead of just an intersection of a string and an object, it is that union-ed
+ * with an intersection of void and an object. This makes it wholly incompatible
+ * with a normal string (which is good, it cannot be misused on assignment or on usage),
+ * while still being comparable with a normal string via === (also good) and castable from a string.
+ */
+export type __String = (string & {
+    __escapedIdentifier: void;
+}) | (void & {
+    __escapedIdentifier: void;
+}) | InternalSymbolName;
+/** ReadonlyMap where keys are `__String`s. */
+export interface ReadonlyUnderscoreEscapedMap<T> {
+    get(key: __String): T | undefined;
+    has(key: __String): boolean;
+    forEach(action: (value: T, key: __String) => void): void;
+    readonly size: number;
+    keys(): Iterator<__String>;
+    values(): Iterator<T>;
+    entries(): Iterator<[__String, T]>;
+}
+/** Map where keys are `__String`s. */
+export interface UnderscoreEscapedMap<T> extends ReadonlyUnderscoreEscapedMap<T> {
+    set(key: __String, value: T): this;
+    delete(key: __String): boolean;
+    clear(): void;
+}
+/** SymbolTable based on ES6 Map interface. */
+export type SymbolTable = UnderscoreEscapedMap<Symbol>;
+export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
+export declare enum AssignmentDeclarationKind {
+    None = 0,
+    ExportsProperty = 1,
+    ModuleExports = 2,
+    PrototypeProperty = 3,
+    Property = 4,
+    Prototype = 5,
+    ObjectDefinePropertyValue = 6,
+    ObjectDefinePropertyExports = 7,
+    ObjectDefinePrototypeProperty = 8
+}
+/** @deprecated Use FileExtensionInfo instead. */
+export interface DiagnosticMessage {
+    key: string;
+    category: DiagnosticCategory;
+    code: number;
+    message: string;
+    reportsUnnecessary?: {};
+    elidedInCompatabilityPyramid?: boolean;
+}
+/**
+ * A linked list of formatted diagnostic messages to be used as part of a multiline message.
+ * It is built from the bottom up, leaving the head to be the "main" diagnostic.
+ * While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,
+ * the difference is that messages are all preformatted in DMC.
+ */
+export interface DiagnosticMessageChain {
+    messageText: string;
+    category: DiagnosticCategory;
+    code: number;
+    next?: DiagnosticMessageChain[];
+}
+export interface Diagnostic extends DiagnosticRelatedInformation {
+    /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
+    reportsUnnecessary?: {};
+    source?: string;
+    relatedInformation?: DiagnosticRelatedInformation[];
+}
+export interface DiagnosticRelatedInformation {
+    category: DiagnosticCategory;
+    code: number;
+    file: SourceFile | undefined;
+    start: number | undefined;
+    length: number | undefined;
+    messageText: string | DiagnosticMessageChain;
+}
+export interface DiagnosticWithLocation extends Diagnostic {
+    file: SourceFile;
+    start: number;
+    length: number;
+}
+export declare enum DiagnosticCategory {
+    Warning = 0,
+    Error = 1,
+    Suggestion = 2,
+    Message = 3
+}
+export declare enum ModuleResolutionKind {
+    Classic = 1,
+    NodeJs = 2
+}
+export interface PluginImport {
+    name: string;
+}
+export interface ProjectReference {
+    /** A normalized path on disk */
+    path: string;
+    /** The path as the user originally wrote it */
+    originalPath?: string;
+    /** True if the output of this reference should be prepended to the output of this project. Only valid for --outFile compilations */
+    prepend?: boolean;
+    /** True if it is intended that this reference form a circularity */
+    circular?: boolean;
+}
+export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
+export interface CompilerOptions {
+    all?: boolean;
+    allowJs?: boolean;
+    allowNonTsExtensions?: boolean;
+    allowSyntheticDefaultImports?: boolean;
+    allowUmdGlobalAccess?: boolean;
+    allowUnreachableCode?: boolean;
+    allowUnusedLabels?: boolean;
+    alwaysStrict?: boolean;
+    baseUrl?: string;
+    /** An error if set - this should only go through the -b pipeline and not actually be observed */
+    build?: boolean;
+    charset?: string;
+    checkJs?: boolean;
+    configFilePath?: string;
+    /** configFile is set as non enumerable property so as to avoid checking of json source files */
+    readonly configFile?: TsConfigSourceFile;
+    declaration?: boolean;
+    declarationMap?: boolean;
+    emitDeclarationOnly?: boolean;
+    declarationDir?: string;
+    diagnostics?: boolean;
+    extendedDiagnostics?: boolean;
+    disableSizeLimit?: boolean;
+    disableSourceOfProjectReferenceRedirect?: boolean;
+    disableSolutionSearching?: boolean;
+    downlevelIteration?: boolean;
+    emitBOM?: boolean;
+    emitDecoratorMetadata?: boolean;
+    experimentalDecorators?: boolean;
+    forceConsistentCasingInFileNames?: boolean;
+    generateCpuProfile?: string;
+    help?: boolean;
+    importHelpers?: boolean;
+    importsNotUsedAsValues?: ImportsNotUsedAsValues;
+    init?: boolean;
+    inlineSourceMap?: boolean;
+    inlineSources?: boolean;
+    isolatedModules?: boolean;
+    jsx?: JsxEmit;
+    keyofStringsOnly?: boolean;
+    lib?: string[];
+    listEmittedFiles?: boolean;
+    listFiles?: boolean;
+    listFilesOnly?: boolean;
+    locale?: string;
+    mapRoot?: string;
+    maxNodeModuleJsDepth?: number;
+    module?: ModuleKind;
+    moduleResolution?: ModuleResolutionKind;
+    newLine?: NewLineKind;
+    noEmit?: boolean;
+    noEmitForJsFiles?: boolean;
+    noEmitHelpers?: boolean;
+    noEmitOnError?: boolean;
+    noErrorTruncation?: boolean;
+    noFallthroughCasesInSwitch?: boolean;
+    noImplicitAny?: boolean;
+    noImplicitReturns?: boolean;
+    noImplicitThis?: boolean;
+    noStrictGenericChecks?: boolean;
+    noUnusedLocals?: boolean;
+    noUnusedParameters?: boolean;
+    noImplicitUseStrict?: boolean;
+    assumeChangesOnlyAffectDirectDependencies?: boolean;
+    noLib?: boolean;
+    noResolve?: boolean;
+    out?: string;
+    outDir?: string;
+    outFile?: string;
+    paths?: MapLike<string[]>;
+    plugins?: PluginImport[];
+    preserveConstEnums?: boolean;
+    preserveSymlinks?: boolean;
+    preserveWatchOutput?: boolean;
+    project?: string;
+    pretty?: boolean;
+    reactNamespace?: string;
+    jsxFactory?: string;
+    composite?: boolean;
+    incremental?: boolean;
+    tsBuildInfoFile?: string;
+    removeComments?: boolean;
+    rootDir?: string;
+    rootDirs?: string[];
+    skipLibCheck?: boolean;
+    skipDefaultLibCheck?: boolean;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    strict?: boolean;
+    strictFunctionTypes?: boolean;
+    strictBindCallApply?: boolean;
+    strictNullChecks?: boolean;
+    strictPropertyInitialization?: boolean;
+    stripInternal?: boolean;
+    suppressExcessPropertyErrors?: boolean;
+    suppressImplicitAnyIndexErrors?: boolean;
+    suppressOutputPathCheck?: boolean;
+    target?: ScriptTarget;
+    traceResolution?: boolean;
+    resolveJsonModule?: boolean;
+    types?: string[];
+    /** Paths used to compute primary types search locations */
+    typeRoots?: string[];
+    version?: boolean;
+    watch?: boolean;
+    esModuleInterop?: boolean;
+    showConfig?: boolean;
+    useDefineForClassFields?: boolean;
+    [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
+}
+export declare enum ModuleKind {
+    None = 0,
+    CommonJS = 1,
+    AMD = 2,
+    UMD = 3,
+    System = 4,
+    ES2015 = 5,
+    ES2020 = 6,
+    ESNext = 99
+}
+export declare enum JsxEmit {
+    None = 0,
+    Preserve = 1,
+    React = 2,
+    ReactNative = 3
+}
+export declare enum ImportsNotUsedAsValues {
+    Remove = 0,
+    Preserve = 1,
+    Error = 2
+}
+export declare enum NewLineKind {
+    CarriageReturnLineFeed = 0,
+    LineFeed = 1
+}
+export interface LineAndCharacter {
+    /** 0-based. */
+    line: number;
+    character: number;
+}
+export declare enum ScriptKind {
+    Unknown = 0,
+    JS = 1,
+    JSX = 2,
+    TS = 3,
+    TSX = 4,
+    External = 5,
+    JSON = 6,
+    /**
+     * Used on extensions that doesn't define the ScriptKind but the content defines it.
+     * Deferred extensions are going to be included in all project contexts.
+     */
+    Deferred = 7
+}
+export declare enum ScriptTarget {
+    ES3 = 0,
+    ES5 = 1,
+    ES2015 = 2,
+    ES2016 = 3,
+    ES2017 = 4,
+    ES2018 = 5,
+    ES2019 = 6,
+    ES2020 = 7,
+    ESNext = 99,
+    JSON = 100,
+    Latest = 99
+}
+export declare enum LanguageVariant {
+    Standard = 0,
+    JSX = 1
+}
+export declare enum CharacterCodes {
+    nullCharacter = 0,
+    maxAsciiCharacter = 127,
+    lineFeed = 10,// \n
+    carriageReturn = 13,// \r
+    lineSeparator = 8232,
+    paragraphSeparator = 8233,
+    nextLine = 133,
+    space = 32,// " "
+    nonBreakingSpace = 160,//
+    enQuad = 8192,
+    emQuad = 8193,
+    enSpace = 8194,
+    emSpace = 8195,
+    threePerEmSpace = 8196,
+    fourPerEmSpace = 8197,
+    sixPerEmSpace = 8198,
+    figureSpace = 8199,
+    punctuationSpace = 8200,
+    thinSpace = 8201,
+    hairSpace = 8202,
+    zeroWidthSpace = 8203,
+    narrowNoBreakSpace = 8239,
+    ideographicSpace = 12288,
+    mathematicalSpace = 8287,
+    ogham = 5760,
+    _ = 95,
+    $ = 36,
+    _0 = 48,
+    _1 = 49,
+    _2 = 50,
+    _3 = 51,
+    _4 = 52,
+    _5 = 53,
+    _6 = 54,
+    _7 = 55,
+    _8 = 56,
+    _9 = 57,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    ampersand = 38,// &
+    asterisk = 42,// *
+    at = 64,// @
+    backslash = 92,// \
+    backtick = 96,// `
+    bar = 124,// |
+    caret = 94,// ^
+    closeBrace = 125,// }
+    closeBracket = 93,// ]
+    closeParen = 41,// )
+    colon = 58,// :
+    comma = 44,// ,
+    dot = 46,// .
+    doubleQuote = 34,// "
+    equals = 61,// =
+    exclamation = 33,// !
+    greaterThan = 62,// >
+    hash = 35,// #
+    lessThan = 60,// <
+    minus = 45,// -
+    openBrace = 123,// {
+    openBracket = 91,// [
+    openParen = 40,// (
+    percent = 37,// %
+    plus = 43,// +
+    question = 63,// ?
+    semicolon = 59,// ;
+    singleQuote = 39,// '
+    slash = 47,// /
+    tilde = 126,// ~
+    backspace = 8,// \b
+    formFeed = 12,// \f
+    byteOrderMark = 65279,
+    tab = 9,// \t
+    verticalTab = 11
+}
+/** O resultado de resolver um import: o arquivo a que ele resolveu. */
+export interface ResolvedModule {
+    /** O caminho do arquivo. */
+    resolvedFileName: string;
+}
+/** A resolução com a extensão do arquivo, que o `check` tira do nome que o host devolve (CK-46). */
+export interface ResolvedModuleFull extends ResolvedModule {
+    /** A extensão do `resolvedFileName`, igual ao fim dele. */
+    extension: Extension;
+}
+export declare enum Extension {
+    Ts = ".ts",
+    Tsx = ".tsx",
+    Dts = ".d.ts",
+    Js = ".js",
+    Jsx = ".jsx",
+    Json = ".json",
+    TsBuildInfo = ".tsbuildinfo"
+}
+export declare enum TransformFlags {
+    None = 0,
+    ContainsTypeScript = 1,
+    ContainsJsx = 2,
+    ContainsESNext = 4,
+    ContainsES2020 = 8,
+    ContainsES2019 = 16,
+    ContainsES2018 = 32,
+    ContainsES2017 = 64,
+    ContainsES2016 = 128,
+    ContainsES2015 = 256,
+    ContainsGenerator = 512,
+    ContainsDestructuringAssignment = 1024,
+    ContainsTypeScriptClassSyntax = 2048,// Decorators, Property Initializers, Parameter Property Initializers
+    ContainsLexicalThis = 4096,
+    ContainsRestOrSpread = 8192,
+    ContainsObjectRestOrSpread = 16384,
+    ContainsComputedPropertyName = 32768,
+    ContainsBlockScopedBinding = 65536,
+    ContainsBindingPattern = 131072,
+    ContainsYield = 262144,
+    ContainsAwait = 524288,
+    ContainsHoistedDeclarationOrCompletion = 1048576,
+    ContainsDynamicImport = 2097152,
+    ContainsClassFields = 4194304,
+    HasComputedFlags = 536870912,// Transform flags have been computed.
+    AssertTypeScript = 1,
+    AssertJsx = 2,
+    AssertESNext = 4,
+    AssertES2020 = 8,
+    AssertES2019 = 16,
+    AssertES2018 = 32,
+    AssertES2017 = 64,
+    AssertES2016 = 128,
+    AssertES2015 = 256,
+    AssertGenerator = 512,
+    AssertDestructuringAssignment = 1024,
+    OuterExpressionExcludes = 536870912,
+    PropertyAccessExcludes = 536870912,
+    NodeExcludes = 536870912,
+    ArrowFunctionExcludes = 538920960,
+    FunctionExcludes = 538925056,
+    ConstructorExcludes = 538923008,
+    MethodOrAccessorExcludes = 538923008,
+    PropertyExcludes = 536875008,
+    ClassExcludes = 536905728,
+    ModuleExcludes = 537991168,
+    TypeExcludes = -2,
+    ObjectLiteralExcludes = 536922112,
+    ArrayLiteralOrCallOrNewExcludes = 536879104,
+    VariableDeclarationListExcludes = 537018368,
+    ParameterExcludes = 536870912,
+    CatchClauseExcludes = 536887296,
+    BindingPatternExcludes = 536879104,
+    PropertyNamePropagatingFlags = 4096
+}
+export interface SourceMapRange extends TextRange {
+    source?: SourceMapSource;
+}
+export interface SourceMapSource {
+    fileName: string;
+    text: string;
+    lineMap: readonly number[];
+    skipTrivia?: (pos: number) => number;
+}
+export interface EmitNode {
+    annotatedNodes?: Node[];
+    flags: EmitFlags;
+    leadingComments?: SynthesizedComment[];
+    trailingComments?: SynthesizedComment[];
+    commentRange?: TextRange;
+    sourceMapRange?: SourceMapRange;
+    tokenSourceMapRanges?: (SourceMapRange | undefined)[];
+    externalHelpersModuleName?: Identifier;
+    externalHelpers?: boolean;
+    helpers?: EmitHelper[];
+    startsOnNewLine?: boolean;
+}
+export declare enum EmitFlags {
+    None = 0,
+    SingleLine = 1,// The contents of this node should be emitted on a single line.
+    AdviseOnEmitNode = 2,// The printer should invoke the onEmitNode callback when printing this node.
+    NoSubstitution = 4,// Disables further substitution of an expression.
+    NoLeadingSourceMap = 16,// Do not emit a leading source map location for this node.
+    NoTrailingSourceMap = 32,// Do not emit a trailing source map location for this node.
+    NoSourceMap = 48,// Do not emit a source map location for this node.
+    NoNestedSourceMaps = 64,// Do not emit source map locations for children of this node.
+    NoTokenLeadingSourceMaps = 128,// Do not emit leading source map location for token nodes.
+    NoTokenTrailingSourceMaps = 256,// Do not emit trailing source map location for token nodes.
+    NoTokenSourceMaps = 384,// Do not emit source map locations for tokens of this node.
+    NoLeadingComments = 512,// Do not emit leading comments for this node.
+    NoTrailingComments = 1024,// Do not emit trailing comments for this node.
+    NoComments = 1536,// Do not emit comments for this node.
+    NoNestedComments = 2048,
+    HelperName = 4096,// The Identifier refers to an *unscoped* emit helper (one that is emitted at the top of the file)
+    ExportName = 8192,// Ensure an export prefix is added for an identifier that points to an exported declaration with a local name (see SymbolFlags.ExportHasLocal).
+    LocalName = 16384,// Ensure an export prefix is not added for an identifier that points to an exported declaration.
+    InternalName = 32768,// The name is internal to an ES5 class body function.
+    Indented = 65536,// Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter).
+    NoIndentation = 131072,// Do not indent the node.
+    AsyncFunctionBody = 262144,
+    ReuseTempVariableScope = 524288,// Reuse the existing temp variable scope during emit.
+    CustomPrologue = 1048576,// Treat the statement as if it were a prologue directive (NOTE: Prologue directives are *not* transformed).
+    NoHoisting = 2097152,// Do not hoist this declaration in --module system
+    HasEndOfDeclarationMarker = 4194304,// Declaration has an associated NotEmittedStatement to mark the end of the declaration
+    Iterator = 8388608,// The expression to a `yield*` should be treated as an Iterator when down-leveling, not an Iterable.
+    NoAsciiEscaping = 16777216,// When synthesizing nodes that lack an original node or textSourceNode, we want to write the text on the node with ASCII escaping substitutions.
+    TypeScriptClassWrapper = 33554432,// The node is an IIFE class wrapper created by the ts transform.
+    NeverApplyImportHelper = 67108864,// Indicates the node should never be wrapped with an import star helper (because, for example, it imports tslib itself)
+    IgnoreSourceNewlines = 134217728
+}
+export interface EmitHelper {
+    readonly name: string;
+    readonly scoped: boolean;
+    readonly text: string | ((node: EmitHelperUniqueNameCallback) => string);
+    readonly priority?: number;
+    readonly dependencies?: EmitHelper[];
+}
+export interface UnscopedEmitHelper extends EmitHelper {
+    readonly scoped: false;
+    readonly importName?: string;
+    readonly text: string;
+}
+export type EmitHelperUniqueNameCallback = (name: string) => string;
+/**
+ * Used by the checker, this enum keeps track of external emit helpers that should be type
+ * checked.
+ */
+export declare enum ExternalEmitHelpers {
+    None = 0,
+    Extends = 1,// __extends (used by the ES2015 class transformation)
+    Assign = 2,// __assign (used by Jsx and ESNext object spread transformations)
+    Rest = 4,// __rest (used by ESNext object rest transformation)
+    Decorate = 8,// __decorate (used by TypeScript decorators transformation)
+    Metadata = 16,// __metadata (used by TypeScript decorators transformation)
+    Param = 32,// __param (used by TypeScript decorators transformation)
+    Awaiter = 64,// __awaiter (used by ES2017 async functions transformation)
+    Generator = 128,// __generator (used by ES2015 generator transformation)
+    Values = 256,// __values (used by ES2015 for..of and yield* transformations)
+    Read = 512,// __read (used by ES2015 iterator destructuring transformation)
+    Spread = 1024,// __spread (used by ES2015 array spread and argument list spread transformations)
+    SpreadArrays = 2048,// __spreadArrays (used by ES2015 array spread and argument list spread transformations)
+    Await = 4096,// __await (used by ES2017 async generator transformation)
+    AsyncGenerator = 8192,// __asyncGenerator (used by ES2017 async generator transformation)
+    AsyncDelegator = 16384,// __asyncDelegator (used by ES2017 async generator yield* transformation)
+    AsyncValues = 32768,// __asyncValues (used by ES2017 for..await..of transformation)
+    ExportStar = 65536,// __exportStar (used by CommonJS/AMD/UMD module transformation)
+    MakeTemplateObject = 131072,// __makeTemplateObject (used for constructing template string array objects)
+    ClassPrivateFieldGet = 262144,// __classPrivateFieldGet (used by the class private field transformation)
+    ClassPrivateFieldSet = 524288,// __classPrivateFieldSet (used by the class private field transformation)
+    CreateBinding = 1048576,// __createBinding (use by the module transform for (re)exports and namespace imports)
+    FirstEmitHelper = 1,
+    LastEmitHelper = 1048576,
+    ForOfIncludes = 256,
+    ForAwaitOfIncludes = 32768,
+    AsyncGeneratorIncludes = 12288,
+    AsyncDelegatorIncludes = 53248,
+    SpreadIncludes = 1536
+}
+export declare enum EmitHint {
+    SourceFile = 0,// Emitting a SourceFile
+    Expression = 1,// Emitting an Expression
+    IdentifierName = 2,// Emitting an IdentifierName
+    MappedTypeParameter = 3,// Emitting a TypeParameterDeclaration inside of a MappedTypeNode
+    Unspecified = 4,// Emitting an otherwise unspecified node
+    EmbeddedStatement = 5,// Emitting an embedded statement
+    JsxAttributeValue = 6
+}
+export declare enum LexicalEnvironmentFlags {
+    None = 0,
+    InParameters = 1,// currently visiting a parameter list
+    VariablesHoistedInParameters = 2
+}
+export interface TransformationContext {
+    /** Gets the compiler options supplied to the transformer. */
+    getCompilerOptions(): CompilerOptions;
+    /** Starts a new lexical environment. */
+    startLexicalEnvironment(): void;
+    setLexicalEnvironmentFlags(flags: LexicalEnvironmentFlags, value: boolean): void;
+    getLexicalEnvironmentFlags(): LexicalEnvironmentFlags;
+    /** Suspends the current lexical environment, usually after visiting a parameter list. */
+    suspendLexicalEnvironment(): void;
+    /** Resumes a suspended lexical environment, usually before visiting a function body. */
+    resumeLexicalEnvironment(): void;
+    /** Ends a lexical environment, returning any declarations. */
+    endLexicalEnvironment(): Statement[] | undefined;
+    /** Hoists a variable declaration to the containing scope. */
+    hoistVariableDeclaration(node: Identifier): void;
+    /** Adds an initialization statement to the top of the lexical environment. */
+    addInitializationStatement(node: Statement): void;
+    /** Records a request for a non-scoped emit helper in the current context. */
+    requestEmitHelper(helper: EmitHelper): void;
+    /** Gets and resets the requested non-scoped emit helpers. */
+    readEmitHelpers(): EmitHelper[] | undefined;
+    /** Enables expression substitutions in the pretty printer for the provided SyntaxKind. */
+    enableSubstitution(kind: SyntaxKind): void;
+    /** Determines whether expression substitutions are enabled for the provided node. */
+    isSubstitutionEnabled(node: Node): boolean;
+    /**
+     * Hook used by transformers to substitute expressions just before they
+     * are emitted by the pretty printer.
+     *
+     * NOTE: Transformation hooks should only be modified during `Transformer` initialization,
+     * before returning the `NodeTransformer` callback.
+     */
+    onSubstituteNode: (hint: EmitHint, node: Node) => Node;
+    /**
+     * Enables before/after emit notifications in the pretty printer for the provided
+     * SyntaxKind.
+     */
+    enableEmitNotification(kind: SyntaxKind): void;
+    /**
+     * Determines whether before/after emit notifications should be raised in the pretty
+     * printer when it emits a node.
+     */
+    isEmitNotificationEnabled(node: Node): boolean;
+    /**
+     * Hook used to allow transformers to capture state before or after
+     * the printer emits a node.
+     *
+     * NOTE: Transformation hooks should only be modified during `Transformer` initialization,
+     * before returning the `NodeTransformer` callback.
+     */
+    onEmitNode: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+    addDiagnostic(diag: DiagnosticWithLocation): void;
+}
+/**
+ * A function that transforms a node.
+ */
+export type Transformer<T extends Node> = (node: T) => T;
+/**
+ * A function that accepts and possibly transforms a node.
+ */
+export type Visitor = (node: Node) => VisitResult<Node>;
+export type VisitResult<T extends Node> = T | T[] | undefined;
+export declare enum BundleFileSectionKind {
+    Prologue = "prologue",
+    EmitHelpers = "emitHelpers",
+    NoDefaultLib = "no-default-lib",
+    Reference = "reference",
+    Type = "type",
+    Lib = "lib",
+    Prepend = "prepend",
+    Text = "text",
+    Internal = "internal"
+}
+export interface BundleFileSectionBase extends TextRange {
+    kind: BundleFileSectionKind;
+    data?: string;
+}
+export interface BundleFilePrologue extends BundleFileSectionBase {
+    kind: BundleFileSectionKind.Prologue;
+    data: string;
+}
+export interface BundleFileEmitHelpers extends BundleFileSectionBase {
+    kind: BundleFileSectionKind.EmitHelpers;
+    data: string;
+}
+export interface BundleFileHasNoDefaultLib extends BundleFileSectionBase {
+    kind: BundleFileSectionKind.NoDefaultLib;
+}
+export interface BundleFileReference extends BundleFileSectionBase {
+    kind: BundleFileSectionKind.Reference | BundleFileSectionKind.Type | BundleFileSectionKind.Lib;
+    data: string;
+}
+export interface BundleFilePrepend extends BundleFileSectionBase {
+    kind: BundleFileSectionKind.Prepend;
+    data: string;
+    texts: BundleFileTextLike[];
+}
+export type BundleFileTextLikeKind = BundleFileSectionKind.Text | BundleFileSectionKind.Internal;
+export interface BundleFileTextLike extends BundleFileSectionBase {
+    kind: BundleFileTextLikeKind;
+}
+export type BundleFileSection = BundleFilePrologue | BundleFileEmitHelpers | BundleFileHasNoDefaultLib | BundleFileReference | BundleFilePrepend | BundleFileTextLike;
+export interface SourceFilePrologueDirectiveExpression extends TextRange {
+    text: string;
+}
+export interface SourceFilePrologueDirective extends TextRange {
+    expression: SourceFilePrologueDirectiveExpression;
+}
+export interface SourceFilePrologueInfo {
+    file: number;
+    text: string;
+    directives: SourceFilePrologueDirective[];
+}
+export interface SourceFileInfo {
+    helpers?: string[];
+    prologues?: SourceFilePrologueInfo[];
+}
+export interface BundleFileInfo {
+    sections: BundleFileSection[];
+    sources?: SourceFileInfo;
+}
+export interface BundleBuildInfo {
+    js?: BundleFileInfo;
+    dts?: BundleFileInfo;
+    commonSourceDirectory: string;
+    sourceFiles: readonly string[];
+}
+export interface BuildInfo {
+    bundle?: BundleBuildInfo;
+    version: string;
+}
+export interface RawSourceMap {
+    version: 3;
+    file: string;
+    sourceRoot?: string | null;
+    sources: string[];
+    sourcesContent?: (string | null)[] | null;
+    mappings: string;
+    names?: string[] | null;
+}
+export interface TextSpan {
+    start: number;
+    length: number;
+}
+export interface TextChangeRange {
+    span: TextSpan;
+    newLength: number;
+}
+export interface SyntaxList extends Node {
+    _children: Node[];
+}
+export declare enum PragmaKindFlags {
+    None = 0,
+    /**
+     * Triple slash comment of the form
+     * /// <pragma-name argname="value" />
+     */
+    TripleSlashXML = 1,
+    /**
+     * Single line comment of the form
+     * // @pragma-name argval1 argval2
+     * or
+     * /// @pragma-name argval1 argval2
+     */
+    SingleLine = 2,
+    /**
+     * Multiline non-jsdoc pragma of the form
+     * /* @pragma-name argval1 argval2 * /
+     */
+    MultiLine = 4,
+    All = 7,
+    Default = 7
+}
+interface PragmaArgumentSpecification<TName extends string> {
+    name: TName;
+    optional?: boolean;
+    captureSpan?: boolean;
+}
+export interface PragmaDefinition<T1 extends string = string, T2 extends string = string, T3 extends string = string, T4 extends string = string> {
+    args?: readonly [PragmaArgumentSpecification<T1>] | readonly [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>] | readonly [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>, PragmaArgumentSpecification<T3>] | readonly [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>, PragmaArgumentSpecification<T3>, PragmaArgumentSpecification<T4>];
+    kind?: PragmaKindFlags;
+}
+export declare const commentPragmas: {
+    readonly reference: {
+        readonly args: readonly [{
+            readonly name: "types";
+            readonly optional: true;
+            readonly captureSpan: true;
+        }, {
+            readonly name: "lib";
+            readonly optional: true;
+            readonly captureSpan: true;
+        }, {
+            readonly name: "path";
+            readonly optional: true;
+            readonly captureSpan: true;
+        }, {
+            readonly name: "no-default-lib";
+            readonly optional: true;
+        }];
+        readonly kind: PragmaKindFlags.TripleSlashXML;
+    };
+    readonly "amd-dependency": {
+        readonly args: readonly [{
+            readonly name: "path";
+        }, {
+            readonly name: "name";
+            readonly optional: true;
+        }];
+        readonly kind: PragmaKindFlags.TripleSlashXML;
+    };
+    readonly "amd-module": {
+        readonly args: readonly [{
+            readonly name: "name";
+        }];
+        readonly kind: PragmaKindFlags.TripleSlashXML;
+    };
+    readonly "ts-check": {
+        readonly kind: PragmaKindFlags.SingleLine;
+    };
+    readonly "ts-nocheck": {
+        readonly kind: PragmaKindFlags.SingleLine;
+    };
+    readonly jsx: {
+        readonly args: readonly [{
+            readonly name: "factory";
+        }];
+        readonly kind: PragmaKindFlags.MultiLine;
+    };
+};
+type PragmaArgTypeMaybeCapture<TDesc> = TDesc extends {
+    captureSpan: true;
+} ? {
+    value: string;
+    pos: number;
+    end: number;
+} : string;
+type PragmaArgTypeOptional<TDesc, TName extends string> = TDesc extends {
+    optional: true;
+} ? {
+    [K in TName]?: PragmaArgTypeMaybeCapture<TDesc>;
+} : {
+    [K in TName]: PragmaArgTypeMaybeCapture<TDesc>;
+};
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ArgumentDefinitionToFieldUnion<T extends readonly PragmaArgumentSpecification<any>[]> = {
+    [K in keyof T]: PragmaArgTypeOptional<T[K], T[K] extends {
+        name: infer TName;
+    } ? TName extends string ? TName : never : never>;
+}[Extract<keyof T, number>];
+/**
+ * Maps a pragma definition into the desired shape for its arguments object
+ */
+type PragmaArgumentType<KPrag extends keyof ConcretePragmaSpecs> = ConcretePragmaSpecs[KPrag] extends {
+    args: readonly PragmaArgumentSpecification<any>[];
+} ? UnionToIntersection<ArgumentDefinitionToFieldUnion<ConcretePragmaSpecs[KPrag]["args"]>> : never;
+type ConcretePragmaSpecs = typeof commentPragmas;
+export type PragmaPseudoMap = {
+    [K in keyof ConcretePragmaSpecs]: {
+        arguments: PragmaArgumentType<K>;
+        range: CommentRange;
+    };
+};
+export type PragmaPseudoMapEntry = {
+    [K in keyof PragmaPseudoMap]: {
+        name: K;
+        args: PragmaPseudoMap[K];
+    };
+}[keyof PragmaPseudoMap];
+export interface ReadonlyPragmaMap extends ReadonlyMap<PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]> {
+    get<TKey extends keyof PragmaPseudoMap>(key: TKey): PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][];
+    forEach(action: <TKey extends keyof PragmaPseudoMap>(value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][], key: TKey) => void): void;
+}
+/**
+ * A strongly-typed es6 map of pragma entries, the values of which are either a single argument
+ * value (if only one was found), or an array of multiple argument values if the pragma is present
+ * in multiple places
+ */
+export interface PragmaMap extends Map<PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]>, ReadonlyPragmaMap {
+    set<TKey extends keyof PragmaPseudoMap>(key: TKey, value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][]): this;
+    get<TKey extends keyof PragmaPseudoMap>(key: TKey): PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][];
+    forEach(action: <TKey extends keyof PragmaPseudoMap>(value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][], key: TKey) => void): void;
+}
+export interface UserPreferences {
+    readonly disableSuggestions?: boolean;
+    readonly quotePreference?: "auto" | "double" | "single";
+    readonly includeCompletionsForModuleExports?: boolean;
+    readonly includeAutomaticOptionalChainCompletions?: boolean;
+    readonly includeCompletionsWithInsertText?: boolean;
+    readonly importModuleSpecifierPreference?: "auto" | "relative" | "non-relative";
+    /** Como o import escreve o `foo/index.ts`: `"foo"`, `"foo/index"` ou `"foo/index.js"`. */
+    readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js";
+    readonly allowTextChangesInNewFiles?: boolean;
+    readonly providePrefixAndSuffixTextForRename?: boolean;
+}
+/** Represents a bigint literal value without requiring bigint support */
+export interface PseudoBigInt {
+    negative: boolean;
+    base10Value: string;
+}
+export {};