@tslite/checker 1.9.0 → 1.12.0

package/dist/types.d.ts

@@ -0,0 +1,864 @@
+import { Map, SymbolFlags, SyntaxKind } from "./_namespaces/ts.js";
+import type { AnyImportSyntax, ArrayTypeNode, BindingElement, CallLikeExpression, CommentDirective, CompilerOptions, ConditionalTypeNode, Declaration, DestructuringPattern, Diagnostic, DiagnosticWithLocation, EmitTextWriter, ExportSpecifier, Expression, Identifier, ImportCall, ImportDeclaration, ImportTypeNode, IndexSignatureDeclaration, JsxAttribute, JsxAttributeLike, JsxAttributes, JsxSpreadAttribute, MappedTypeNode, ModuleSpecifierResolutionHost, Node, NodeArray, ObjectLiteralElementLike, ObjectLiteralExpression, ParameterDeclaration, PropertyAccessExpression, PseudoBigInt, QualifiedName, SignatureDeclaration, SourceFile, Symbol, SymbolTable, SymbolTracker, TupleTypeNode, TypeNode, TypeOnlyCompatibleAliasDeclaration, TypeParameterDeclaration, TypeReferenceNode, __String } from "./_namespaces/ts.js";
+declare module "@tslite/parser" {
+    interface Node {
+        contextualType?: Type;
+        inferenceContext?: InferenceContext;
+    }
+}
+export declare enum JsxFlags {
+    None = 0,
+    /** An element from a named property of the JSX.IntrinsicElements interface */
+    IntrinsicNamedElement = 1,
+    /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
+    IntrinsicIndexedElement = 2,
+    IntrinsicElement = 3
+}
+export declare enum RelationComparisonResult {
+    None = 0,
+    Succeeded = 1,// Should be truthy
+    Failed = 2,
+    Reported = 4,
+    ReportsUnmeasurable = 8,
+    ReportsUnreliable = 16,
+    ReportsMask = 24
+}
+export interface SyntheticExpression extends Expression {
+    kind: SyntaxKind.SyntheticExpression;
+    isSpread: boolean;
+    type: Type;
+}
+export type FlowType = Type | IncompleteType;
+export interface IncompleteType {
+    flags: TypeFlags;
+    type: Type;
+}
+export declare class OperationCanceledException {
+}
+export interface CancellationToken {
+    isCancellationRequested(): boolean;
+    /** @throws OperationCanceledException if isCancellationRequested is true */
+    throwIfCancellationRequested(): void;
+}
+export interface TypeCheckerHost extends ModuleSpecifierResolutionHost {
+    getCompilerOptions(): CompilerOptions;
+    getSourceFiles(): readonly SourceFile[];
+    getSourceFile(fileName: string): SourceFile | undefined;
+}
+export interface TypeChecker {
+    getPropertiesOfType(type: Type): Symbol[];
+    getSignaturesOfType(type: Type): readonly Signature[];
+    getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
+    getSymbolAtLocation(node: Node): Symbol | undefined;
+    getTypeAtLocation(node: Node): Type;
+    typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
+    symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): string;
+    getAugmentedPropertiesOfType(type: Type): Symbol[];
+    getContextualType(node: Expression, contextFlags?: ContextFlags): Type | undefined;
+    isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName | ImportTypeNode, propertyName: string): boolean;
+    isTypeAssignableTo(source: Type, target: Type): boolean;
+    getTypeOfSymbolAtLocation(symbol: Symbol, location: Node): Type;
+    getPropertyOfType(type: Type, propertyName: string): Symbol | undefined;
+    getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined;
+    /** O tipo que a promise entrega: o argumento do `Promise<T>`, ou o valor do `then` de um thenable. */
+    getPromisedTypeOfPromise(promise: Type): Type | undefined;
+    isNullableType(type: Type): boolean;
+    getNonNullableType(type: Type): Type;
+    /** O tipo sem o `undefined` que marca o membro opcional. */
+    getNonOptionalType(type: Type): Type;
+    getTypeArguments(type: TypeReference): readonly Type[];
+    getBaseConstraintOfType(type: Type): Type | undefined;
+    getDefaultFromTypeParameter(type: Type): Type | undefined;
+    getReturnTypeOfSignature(signature: Signature): Type;
+    getStringType(): Type;
+    getNumberType(): Type;
+    getBooleanType(): Type;
+    isUndefinedSymbol(symbol: Symbol): boolean;
+    getMergedSymbol(symbol: Symbol): Symbol;
+    getDeclaredTypeOfSymbol(symbol: Symbol): Type;
+    getTypeFromTypeNode(node: TypeNode): Type;
+    getParameterType(signature: Signature, parameterIndex: number): Type;
+    symbolToTypeParameterDeclarations(symbol: Symbol, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): NodeArray<TypeParameterDeclaration> | undefined;
+    typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeParameterDeclaration | undefined;
+    /** Na tag, também o `kind`, que imprimia a construct signature (CK-02). */
+    writeSignature(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, writer?: EmitTextWriter): string;
+    writeType(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags, writer?: EmitTextWriter): string;
+    writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags, writer?: EmitTextWriter): string;
+    getRootSymbols(symbol: Symbol): readonly Symbol[];
+    getContextualTypeForArgumentAtIndex(call: CallLikeExpression, argIndex: number): Type | undefined;
+    getContextualTypeForJsxAttribute(attribute: JsxAttribute | JsxSpreadAttribute): Type | undefined;
+    getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
+    isValidPropertyAccessForCompletions(node: PropertyAccessExpression | ImportTypeNode | QualifiedName, type: Type, property: Symbol): boolean;
+    getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined;
+    getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined;
+    getAliasedSymbol(symbol: Symbol): Symbol;
+    getExportsOfModule(moduleSymbol: Symbol): Symbol[];
+    getExportsAndPropertiesOfModule(moduleSymbol: Symbol): Symbol[];
+    getJsxIntrinsicTagNamesAt(location: Node): Symbol[];
+    tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
+    /** Como o `tryGetMemberInModuleExports`. Na tag, também a propriedade do valor do `export =` (CK-03). */
+    tryGetMemberInModuleExportsAndProperties(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
+    getUnionType(types: Type[], subtypeReduction?: UnionReduction): Type;
+    isArrayLikeType(type: Type): boolean;
+    isTypeInvalidDueToUnionDiscriminant(contextualType: Type, obj: ObjectLiteralExpression | JsxAttributes): boolean;
+    getAllPossiblePropertiesOfTypes(type: readonly Type[]): Symbol[];
+    /**
+     * @param useOnlyExternalAliasing sem ele, qualquer alias em escopo dá o nome; com ele, nenhum. Na tag, com ele, só o
+     *   alias do `import x = require()`, que saiu (CK-03).
+     */
+    getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, useOnlyExternalAliasing: boolean): Symbol[] | undefined;
+    getTypeArgumentConstraint(node: TypeNode): Type | undefined;
+    runWithCancellationToken<T>(token: CancellationToken, cb: (checker: TypeChecker) => T): T;
+    /** O valor a que o nome de uma propriedade abreviada (`{ x }`) se refere: o símbolo local, e não a propriedade. */
+    getShorthandAssignmentValueSymbol(location: Node): Symbol | undefined;
+    /** O alvo de um export specifier, sem seguir os aliases. */
+    getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol | undefined;
+    /** A propriedade a que o nome de uma atribuição por desestruturação corresponde. */
+    getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol | undefined;
+    /** O nome do símbolo com os contêineres dele: o `N.x` de um membro de namespace. */
+    getFullyQualifiedName(symbol: Symbol): string;
+    /** Se o símbolo é o que o checker dá ao nome que não resolve. */
+    isUnknownSymbol(symbol: Symbol): boolean;
+    getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined;
+    /** Se a declaração é visível de fora do lugar em que está: exportada, ou no escopo global. */
+    isDeclarationVisible(node: Declaration | AnyImportSyntax): boolean;
+    /**
+     * O `getResolvedSignature` do signature help: a vírgula final da chamada conta como mais um argumento, e só servem os
+     * overloads que o aceitam.
+     */
+    getResolvedSignatureForSignatureHelp(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
+    symbolToParameterDeclaration(symbol: Symbol, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): ParameterDeclaration | undefined;
+    /** Na tag, também o predicado do `this` (CK-02). */
+    writeTypePredicate(predicate: TypePredicate, enclosingDeclaration?: Node, flags?: TypeFormatFlags, writer?: EmitTextWriter): string;
+    /** Os parâmetros da assinatura, com o rest de tupla aberto em um parâmetro por elemento. */
+    getExpandedParameters(sig: Signature): readonly Symbol[];
+    hasEffectiveRestParameter(sig: Signature): boolean;
+    isOptionalParameter(node: ParameterDeclaration): boolean;
+    getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined;
+    /** Os parâmetros de tipo do alias. Na tag, também os da classe e os da interface (CK-02, CK-48). */
+    getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol: Symbol): readonly TypeParameter[] | undefined;
+    typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode | undefined;
+    typeToTypeNode(type: Type, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined, tracker?: SymbolTracker): TypeNode | undefined;
+    /** Na tag, também os aliases a tornar visíveis, que o declaration emit calculava (CK-03, P03). */
+    isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): SymbolAccessibilityResult;
+    getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined;
+    getBaseTypeOfLiteralType(type: Type): Type;
+    getWidenedType(type: Type): Type;
+    getAnyType(): Type;
+    getVoidType(): Type;
+    getUndefinedType(): Type;
+    createArrayType(elementType: Type): Type;
+    getElementTypeOfArrayType(arrayType: Type): Type | undefined;
+    createPromiseType(type: Type): Type;
+    /** Na tag, também as construct signatures (CK-02). */
+    createAnonymousType(symbol: Symbol | undefined, members: SymbolTable, callSignatures: Signature[], stringIndexInfo: IndexInfo | undefined, numberIndexInfo: IndexInfo | undefined): Type;
+    /** Na tag, também o parâmetro `this` (CK-02). */
+    createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[] | undefined, parameters: Symbol[], resolvedReturnType: Type, typePredicate: TypePredicate | undefined, minArgumentCount: number, flags: SignatureFlags): Signature;
+    createSymbol(flags: SymbolFlags, name: __String): TransientSymbol;
+    createIndexInfo(type: Type, isReadonly: boolean, declaration?: SignatureDeclaration): IndexInfo;
+    /** Na tag, o nome podia ser também um `#private` (CK-02). */
+    getSuggestedSymbolForNonexistentProperty(name: Identifier | string, containingType: Type): Symbol | undefined;
+    getSuggestedSymbolForNonexistentSymbol(location: Node, name: string, meaning: SymbolFlags): Symbol | undefined;
+    getSuggestedSymbolForNonexistentModule(node: Identifier, target: Symbol): Symbol | undefined;
+    /** O símbolo que o nome alcança a partir do lugar, com o significado pedido; com o `excludeGlobals`, sem os globais. */
+    resolveName(name: string, location: Node | undefined, meaning: SymbolFlags, excludeGlobals: boolean): Symbol | undefined;
+    isArrayType(type: Type): boolean;
+    isTupleType(type: Type): boolean;
+    /** Na tag, também o método de um object literal (CK-02). */
+    isContextSensitive(node: Expression | ObjectLiteralElementLike | JsxAttributeLike): boolean;
+    getSymbolWalker(accept?: (symbol: Symbol) => boolean): SymbolWalker;
+    /**
+     * O tipo está adiado por um parâmetro de tipo que não foi instanciado: o próprio parâmetro, o acesso indexado e o
+     * conditional sobre ele, e o mapped sobre um `keyof` genérico; a união e a interseção, quando um membro está. O
+     * `keyof T` não está: é um tipo primitivo, e não objeto.
+     */
+    isGenericObjectType(type: Type): boolean;
+    /**
+     * O tipo `source` é comparável ao `target`: a relação da igualdade (o TS2367), do `case` contra o `switch` e da
+     * asserção (o TS2352), que pergunta se os dois podem ser o mesmo valor, e não se um cabe no outro. A relação simples
+     * (o primitivo, o literal, o `any`, o `unknown`) vale nos dois sentidos, e a estrutural, não: o objeto com mais
+     * propriedades é comparável ao que tem menos, e não o contrário. A igualdade aceita os dois quando um dos sentidos
+     * aceita. O literal não se alarga: o `as` alarga o da expressão antes de perguntar.
+     */
+    isTypeComparableTo(source: Type, target: Type): boolean;
+    getDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
+    getGlobalDiagnostics(): Diagnostic[];
+    /**
+     * Does *not* get *all* suggestion diagnostics, just the ones that were convenient to report in the checker.
+     * Others are added in computeSuggestionDiagnostics.
+     */
+    getSuggestionDiagnostics(file: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
+}
+export interface SymbolWalker {
+    /** Note: Return values are not ordered. */
+    walkType(root: Type): {
+        visitedTypes: readonly Type[];
+        visitedSymbols: readonly Symbol[];
+    };
+    /** Note: Return values are not ordered. */
+    walkSymbol(root: Symbol): {
+        visitedTypes: readonly Type[];
+        visitedSymbols: readonly Symbol[];
+    };
+}
+export declare enum UnionReduction {
+    None = 0,
+    Literal = 1,
+    Subtype = 2
+}
+export declare enum ContextFlags {
+    None = 0,
+    Signature = 1,// Obtaining contextual signature
+    NoConstraints = 2,// Don't obtain type variable constraints
+    Completions = 4
+}
+export declare enum NodeBuilderFlags {
+    None = 0,
+    NoTruncation = 1,// Don't truncate result
+    WriteArrayAsGenericType = 2,// Write Array<T> instead T[]
+    GenerateNamesForShadowedTypeParams = 4,// When a type parameter T is shadowing another T, generate a name for it so it can still be referenced
+    UseStructuralFallback = 8,// When an alias cannot be named by its symbol, rather than report an error, fallback to a structural printout if possible
+    ForbidIndexedAccessSymbolReferences = 16,// Forbid references like `I["a"]["b"]` - print `typeof I.a<x>.b<y>` instead
+    WriteTypeArgumentsOfSignature = 32,// Write the type arguments instead of type parameters of the signature
+    UseFullyQualifiedType = 64,// Write out the fully qualified type name (eg. Module.Type, instead of Type)
+    UseOnlyExternalAliasing = 128,// Only use external aliases for a symbol
+    SuppressAnyReturnType = 256,// If the return type is any-like, don't offer a return type.
+    WriteTypeParametersInQualifiedName = 512,
+    MultilineObjectLiterals = 1024,// Always write object literals across multiple lines
+    UseTypeOfFunction = 4096,// Build using typeof instead of function type literal
+    OmitParameterModifiers = 8192,// Omit modifiers on parameters
+    UseAliasDefinedOutsideCurrentScope = 16384,// Allow non-visible aliases
+    UseSingleQuotesForStringLiteralType = 268435456,// Use single quotes for string literal type
+    NoTypeReduction = 536870912,// Don't call getReducedType
+    AllowQualifedNameInPlaceOfIdentifier = 65536,
+    AllowAnonymousIdentifier = 131072,
+    AllowEmptyUnionOrIntersection = 262144,
+    AllowEmptyTuple = 524288,
+    AllowUniqueESSymbolType = 1048576,
+    AllowEmptyIndexInfoType = 2097152,
+    AllowNodeModulesRelativePaths = 67108864,
+    DoNotIncludeSymbolChain = 134217728,// Skip looking up and printing an accessible symbol chain
+    IgnoreErrors = 70189056,
+    InTypeAlias = 8388608,// Writing type in type alias declaration
+    InInitialEntityName = 16777216,// Set when writing the LHS of an entity name or entity name expression
+    InReverseMappedType = 33554432
+}
+export declare enum TypeFormatFlags {
+    None = 0,
+    NoTruncation = 1,// Don't truncate typeToString result
+    WriteArrayAsGenericType = 2,// Write Array<T> instead T[]
+    UseStructuralFallback = 8,// When an alias cannot be named by its symbol, rather than report an error, fallback to a structural printout if possible
+    WriteTypeArgumentsOfSignature = 32,// Write the type arguments instead of type parameters of the signature
+    UseFullyQualifiedType = 64,// Write out the fully qualified type name (eg. Module.Type, instead of Type)
+    SuppressAnyReturnType = 256,// If the return type is any-like, don't offer a return type.
+    MultilineObjectLiterals = 1024,// Always print object literals across multiple lines (only used to map into node builder flags)
+    UseTypeOfFunction = 4096,// Write typeof instead of function type literal
+    OmitParameterModifiers = 8192,// Omit modifiers on parameters
+    UseAliasDefinedOutsideCurrentScope = 16384,// For a `type T = ... ` defined in a different file, write `T` instead of its value, even though `T` can't be accessed in the current scope.
+    UseSingleQuotesForStringLiteralType = 268435456,// Use single quotes for string literal type
+    NoTypeReduction = 536870912,// Don't call getReducedType
+    AllowUniqueESSymbolType = 1048576,// This is bit 20 to align with the same bit in `NodeBuilderFlags`
+    AddUndefined = 131072,// Add undefined to types of initialized, non-optional parameters
+    WriteArrowStyleSignature = 262144,// Write arrow style signature
+    InArrayType = 524288,// Writing an array element type
+    InElementType = 2097152,// Writing an array or union element type
+    InFirstTypeArgument = 4194304,// Writing first type argument of the instantiated type
+    InTypeAlias = 8388608,// Writing type in type alias declaration
+    /** @deprecated */ WriteOwnNameForAnyLike = 0,// Does nothing
+    NodeBuilderFlagsMask = 814773611
+}
+export declare enum SymbolFormatFlags {
+    None = 0,
+    WriteTypeParametersOrArguments = 1,
+    UseOnlyExternalAliasing = 2,
+    AllowAnyNodeKind = 4,
+    UseAliasDefinedOutsideCurrentScope = 8,
+    DoNotIncludeSymbolChain = 16
+}
+export declare enum SymbolAccessibility {
+    Accessible = 0,
+    NotAccessible = 1,
+    CannotBeNamed = 2
+}
+export declare enum TypePredicateKind {
+    Identifier = 0,
+    AssertsIdentifier = 1
+}
+export interface TypePredicateBase {
+    kind: TypePredicateKind;
+    type: Type | undefined;
+}
+export interface IdentifierTypePredicate extends TypePredicateBase {
+    kind: TypePredicateKind.Identifier;
+    parameterName: string;
+    parameterIndex: number;
+    type: Type;
+}
+export interface AssertsIdentifierTypePredicate extends TypePredicateBase {
+    kind: TypePredicateKind.AssertsIdentifier;
+    parameterName: string;
+    parameterIndex: number;
+    type: Type | undefined;
+}
+export type TypePredicate = IdentifierTypePredicate | AssertsIdentifierTypePredicate;
+export interface SymbolVisibilityResult {
+    accessibility: SymbolAccessibility;
+}
+export interface SymbolAccessibilityResult extends SymbolVisibilityResult {
+}
+export interface SymbolLinks {
+    immediateTarget?: Symbol;
+    target?: Symbol;
+    type?: Type;
+    nameType?: Type;
+    declaredType?: Type;
+    typeParameters?: TypeParameter[];
+    outerTypeParameters?: TypeParameter[];
+    instantiations?: Map<Type>;
+    inferredClassSymbol?: Map<TransientSymbol>;
+    mapper?: TypeMapper;
+    containingType?: UnionOrIntersectionType;
+    leftSpread?: Symbol;
+    rightSpread?: Symbol;
+    syntheticOrigin?: Symbol;
+    isDiscriminantProperty?: boolean;
+    resolvedExports?: SymbolTable;
+    resolvedMembers?: SymbolTable;
+    exportsChecked?: boolean;
+    isDeclarationWithCollidingName?: boolean;
+    bindingElement?: BindingElement;
+    exportsSomeValue?: boolean;
+    originatingImport?: ImportDeclaration | ImportCall;
+    lateSymbol?: Symbol;
+    specifierCache?: Map<string>;
+    extendedContainers?: Symbol[];
+    extendedContainersByFile?: Map<Symbol[]>;
+    variances?: VarianceFlags[];
+    deferralConstituents?: Type[];
+    deferralParent?: Type;
+    cjsExportMerged?: Symbol;
+    typeOnlyDeclaration?: TypeOnlyCompatibleAliasDeclaration | false;
+}
+export declare enum CheckFlags {
+    None = 0,
+    Instantiated = 1,// Instantiated symbol
+    SyntheticProperty = 2,// Property in union or intersection type
+    SyntheticMethod = 4,// Method in union or intersection type
+    Readonly = 8,// Readonly transient symbol
+    ReadPartial = 16,// Synthetic property present in some but not all constituents
+    WritePartial = 32,// Synthetic property present in some but only satisfied by an index signature in others
+    HasNonUniformType = 64,// Synthetic property with non-uniform type in constituents
+    HasLiteralType = 128,// Synthetic property with at least one literal type in constituents
+    Late = 4096,// Late-bound symbol for a computed property with a dynamic name
+    ReverseMapped = 8192,// Property of reverse-inferred homomorphic mapped type
+    OptionalParameter = 16384,// Optional parameter
+    RestParameter = 32768,// Rest parameter
+    DeferredType = 65536,// Calculation of the type of this symbol is deferred due to processing costs, should be fetched with `getTypeOfSymbolWithDeferredType`
+    HasNeverType = 131072,// Synthetic property with at least one never type in constituents
+    Mapped = 262144,// Property of mapped type
+    StripOptional = 524288,// Strip optionality in mapped property
+    Synthetic = 6,
+    Discriminant = 192,
+    Partial = 48
+}
+export interface TransientSymbol extends Symbol, SymbolLinks {
+    checkFlags: CheckFlags;
+}
+export interface MappedSymbol extends TransientSymbol {
+    mappedType: MappedType;
+    mapper: TypeMapper;
+}
+export interface ReverseMappedSymbol extends TransientSymbol {
+    propertyType: Type;
+    mappedType: MappedType;
+    constraintType: IndexType;
+}
+export declare enum NodeCheckFlags {
+    None = 0,
+    TypeChecked = 1,// Node has been type checked
+    CaptureNewTarget = 8,// Lexical 'new.target' used in body
+    ContextChecked = 1024,// Contextual types have been assigned
+    CaptureArguments = 8192,// Lexical 'arguments' used in body
+    LoopWithCapturedBlockScopedBinding = 65536,// Loop that contains block scoped variable captured in closure
+    ContainsCapturedBlockScopeBinding = 131072,// Part of a loop that contains block scoped variable captured in closure
+    CapturedBlockScopedBinding = 262144,// Block-scoped binding that is captured in some function
+    BlockScopedBindingInLoop = 524288,// Block-scoped binding with declaration nested inside iteration statement
+    NeedsLoopOutParameter = 4194304,// Block scoped binding whose value should be explicitly copied outside of the converted loop
+    AssignmentsMarked = 8388608
+}
+export interface NodeLinks {
+    flags: NodeCheckFlags;
+    resolvedType?: Type;
+    resolvedSignature?: Signature;
+    resolvedSymbol?: Symbol;
+    resolvedIndexInfo?: IndexInfo;
+    effectsSignature?: Signature;
+    isVisible?: boolean;
+    containsArgumentsReference?: boolean;
+    hasReportedStatementInAmbientContext?: boolean;
+    jsxFlags: JsxFlags;
+    resolvedJsxElementAttributesType?: Type;
+    resolvedJsxElementAllAttributesType?: Type;
+    switchTypes?: Type[];
+    contextFreeType?: Type;
+    deferredNodes?: Map<Node>;
+    capturedBlockScopeBindings?: Symbol[];
+    outerTypeParameters?: TypeParameter[];
+    instantiations?: Map<Type>;
+    isExhaustive?: boolean;
+    skipDirectInference?: true;
+}
+export declare enum TypeFlags {
+    None = 0,
+    Any = 1,
+    Unknown = 2,
+    String = 4,
+    Number = 8,
+    Boolean = 16,
+    BigInt = 64,
+    StringLiteral = 128,
+    NumberLiteral = 256,
+    BooleanLiteral = 512,
+    BigIntLiteral = 2048,
+    ESSymbol = 4096,// Type of symbol primitive introduced in ES6
+    Void = 16384,
+    Undefined = 32768,
+    Null = 65536,
+    Never = 131072,// Never type
+    TypeParameter = 262144,// Type parameter
+    Object = 524288,// Object type
+    Union = 1048576,// Union (T | U)
+    Intersection = 2097152,// Intersection (T & U)
+    Index = 4194304,// keyof T
+    IndexedAccess = 8388608,// T[K]
+    Conditional = 16777216,// T extends U ? X : Y
+    Substitution = 33554432,// Type parameter substitution
+    NonPrimitive = 67108864,// intrinsic object type
+    AnyOrUnknown = 3,
+    Nullable = 98304,
+    Literal = 2944,
+    Unit = 101248,
+    StringOrNumberLiteral = 384,
+    DefinitelyFalsy = 117632,
+    PossiblyFalsy = 117724,
+    Intrinsic = 67359327,
+    Primitive = 121820,
+    StringLike = 132,
+    NumberLike = 264,
+    BigIntLike = 2112,
+    BooleanLike = 528,
+    ESSymbolLike = 4096,
+    VoidLike = 49152,
+    DisjointDomains = 67230684,
+    UnionOrIntersection = 3145728,
+    StructuredType = 3670016,
+    TypeVariable = 8650752,
+    InstantiableNonPrimitive = 58982400,
+    InstantiablePrimitive = 4194304,
+    Instantiable = 63176704,
+    StructuredOrInstantiable = 66846720,
+    ObjectFlagsType = 3899393,
+    Simplifiable = 25165824,
+    Substructure = 66584576,
+    Narrowable = 133962719,
+    NotUnionOrUnit = 67637251,
+    NotPrimitiveUnion = 66994179,
+    IncludesMask = 71031775,
+    IncludesStructuredOrInstantiable = 262144,
+    IncludesNonWideningType = 4194304,
+    IncludesWildcard = 8388608,
+    IncludesEmptyObject = 16777216
+}
+export interface Type {
+    flags: TypeFlags;
+    id: number;
+    checker: TypeChecker;
+    symbol: Symbol;
+    pattern?: DestructuringPattern;
+    aliasSymbol?: Symbol;
+    aliasTypeArguments?: readonly Type[];
+    aliasTypeArgumentsContainsMarker?: boolean;
+    permissiveInstantiation?: Type;
+    restrictiveInstantiation?: Type;
+    immediateBaseConstraint?: Type;
+    widened?: Type;
+}
+export interface IntrinsicType extends Type {
+    intrinsicName: string;
+    objectFlags: ObjectFlags;
+}
+export interface NullableType extends IntrinsicType {
+    objectFlags: ObjectFlags;
+}
+export interface FreshableIntrinsicType extends IntrinsicType {
+    freshType: IntrinsicType;
+    regularType: IntrinsicType;
+}
+export type FreshableType = LiteralType | FreshableIntrinsicType;
+export interface LiteralType extends Type {
+    value: string | number | PseudoBigInt;
+    freshType: LiteralType;
+    regularType: LiteralType;
+}
+export interface StringLiteralType extends LiteralType {
+    value: string;
+}
+export interface NumberLiteralType extends LiteralType {
+    value: number;
+}
+export interface BigIntLiteralType extends LiteralType {
+    value: PseudoBigInt;
+}
+export declare enum ObjectFlags {
+    None = 0,
+    Interface = 2,// Interface
+    Reference = 4,// Generic type reference
+    Tuple = 8,// Synthesized generic tuple type
+    Anonymous = 16,// Anonymous
+    Mapped = 32,// Mapped
+    Instantiated = 64,// Instantiated anonymous or mapped type
+    ObjectLiteral = 128,// Originates in an object literal
+    EvolvingArray = 256,// Evolving array type
+    ObjectLiteralPatternWithComputedProperties = 512,// Object literal pattern with computed properties
+    ContainsSpread = 1024,// Object literal contains spread operation
+    ReverseMapped = 2048,// Object contains a property from a reverse-mapped type
+    JsxAttributes = 4096,// Jsx attributes type
+    MarkerType = 8192,// Marker type used for variance probing
+    JSLiteral = 16384,// Object type declared in JS - disables errors on read/write of nonexisting members
+    FreshLiteral = 32768,// Fresh object literal
+    ArrayLiteral = 65536,// Originates in an array literal
+    ObjectRestType = 131072,// Originates in object rest declaration
+    PrimitiveUnion = 262144,// Union of only primitive types
+    ContainsWideningType = 524288,// Type is or contains undefined or null widening type
+    ContainsObjectOrArrayLiteral = 1048576,// Type is or contains object literal type
+    NonInferrableType = 2097152,// Type is or contains anyFunctionType or silentNeverType
+    IsGenericObjectTypeComputed = 4194304,// IsGenericObjectType flag has been computed
+    IsGenericObjectType = 8388608,// Union or intersection contains generic object type
+    IsGenericIndexTypeComputed = 16777216,// IsGenericIndexType flag has been computed
+    IsGenericIndexType = 33554432,// Union or intersection contains generic index type
+    CouldContainTypeVariablesComputed = 67108864,// CouldContainTypeVariables flag has been computed
+    CouldContainTypeVariables = 134217728,// Type could contain a type variable
+    ContainsIntersections = 268435456,// Union contains intersections
+    IsNeverIntersectionComputed = 268435456,// IsNeverLike flag has been computed
+    IsNeverIntersection = 536870912,// Intersection reduces to never
+    ClassOrInterface = 2,
+    RequiresWidening = 1572864,
+    PropagatingFlags = 3670016
+}
+export type ObjectFlagsType = NullableType | ObjectType | UnionType | IntersectionType;
+export interface ObjectType extends Type {
+    objectFlags: ObjectFlags;
+    members?: SymbolTable;
+    properties?: Symbol[];
+    callSignatures?: readonly Signature[];
+    stringIndexInfo?: IndexInfo;
+    numberIndexInfo?: IndexInfo;
+}
+/** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */
+export interface InterfaceType extends ObjectType {
+    typeParameters: TypeParameter[] | undefined;
+    outerTypeParameters: TypeParameter[] | undefined;
+    localTypeParameters: TypeParameter[] | undefined;
+    resolvedBaseTypes: BaseType[];
+}
+export type BaseType = ObjectType | IntersectionType | TypeVariable;
+export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
+    declaredProperties: Symbol[];
+    declaredCallSignatures: Signature[];
+    declaredStringIndexInfo?: IndexInfo;
+    declaredNumberIndexInfo?: IndexInfo;
+}
+/**
+ * A referência a um tipo genérico (`ObjectFlags.Reference`): o alvo e os argumentos de tipo, um para cada parâmetro de
+ * tipo do alvo, na ordem.
+ */
+export interface TypeReference extends ObjectType {
+    target: GenericType;
+    node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+    mapper?: TypeMapper;
+    resolvedTypeArguments?: readonly Type[];
+    literalType?: TypeReference;
+}
+export interface DeferredTypeReference extends TypeReference {
+    node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+    mapper?: TypeMapper;
+}
+export declare enum VarianceFlags {
+    Invariant = 0,// Neither covariant nor contravariant
+    Covariant = 1,// Covariant
+    Contravariant = 2,// Contravariant
+    Bivariant = 3,// Both covariant and contravariant
+    Independent = 4,// Unwitnessed type parameter
+    VarianceMask = 7,// Mask containing all measured variances without the unmeasurable flag
+    Unmeasurable = 8,// Variance result is unusable - relationship relies on structural comparisons which are not reflected in generic relationships
+    Unreliable = 16,// Variance result is unreliable - checking may produce false negatives, but not false positives
+    AllowsStructuralFallback = 24
+}
+export interface GenericType extends InterfaceType, TypeReference {
+    instantiations: Map<TypeReference>;
+    variances?: VarianceFlags[];
+}
+export interface TupleType extends GenericType {
+    minLength: number;
+    hasRestElement: boolean;
+    readonly: boolean;
+    associatedNames?: __String[];
+}
+export interface TupleTypeReference extends TypeReference {
+    target: TupleType;
+}
+export interface UnionOrIntersectionType extends Type {
+    types: Type[];
+    objectFlags: ObjectFlags;
+    propertyCache: SymbolTable;
+    resolvedProperties: Symbol[];
+    resolvedIndexType: IndexType;
+    resolvedBaseConstraint: Type;
+}
+export interface UnionType extends UnionOrIntersectionType {
+    resolvedReducedType: Type;
+    regularType: UnionType;
+}
+export interface IntersectionType extends UnionOrIntersectionType {
+    resolvedApparentType: Type;
+}
+export type StructuredType = ObjectType | UnionType | IntersectionType;
+export interface AnonymousType extends ObjectType {
+    target?: AnonymousType;
+    mapper?: TypeMapper;
+    /**
+     * Num tipo que o checker monta sem declaração (o membro de um embutido, CK-48): os parâmetros de tipo de fora, que o
+     * do programa tira da declaração, e o cache das instanciações por eles, que o do programa guarda nos links dela.
+     */
+    outerTypeParameters?: TypeParameter[];
+    instantiations?: Map<Type>;
+}
+export interface MappedType extends AnonymousType {
+    declaration: MappedTypeNode;
+    typeParameter?: TypeParameter;
+    constraintType?: Type;
+    templateType?: Type;
+    modifiersType?: Type;
+    resolvedApparentType?: Type;
+}
+export interface EvolvingArrayType extends ObjectType {
+    elementType: Type;
+    finalArrayType?: Type;
+}
+export interface ReverseMappedType extends ObjectType {
+    source: Type;
+    mappedType: MappedType;
+    constraintType: IndexType;
+}
+export interface ResolvedType extends ObjectType, UnionOrIntersectionType {
+    members: SymbolTable;
+    properties: Symbol[];
+    callSignatures: readonly Signature[];
+}
+export interface FreshObjectLiteralType extends ResolvedType {
+    regularType: ResolvedType;
+}
+export interface IterationTypes {
+    readonly yieldType: Type;
+    readonly returnType: Type;
+    readonly nextType: Type;
+}
+export interface IterableOrIteratorType extends ObjectType, UnionType {
+    iterationTypesOfIterable?: IterationTypes;
+    iterationTypesOfAsyncIterable?: IterationTypes;
+}
+export interface PromiseOrAwaitableType extends ObjectType, UnionType {
+    promiseTypeOfPromiseConstructor?: Type;
+    promisedTypeOfPromise?: Type;
+    awaitedTypeOfType?: Type;
+}
+export interface InstantiableType extends Type {
+    resolvedBaseConstraint?: Type;
+    resolvedIndexType?: IndexType;
+}
+export interface TypeParameter extends InstantiableType {
+    /** Retrieve using getConstraintFromTypeParameter */
+    constraint?: Type;
+    default?: Type;
+    target?: TypeParameter;
+    mapper?: TypeMapper;
+    resolvedDefaultType?: Type;
+}
+export interface IndexedAccessType extends InstantiableType {
+    objectType: Type;
+    indexType: Type;
+    constraint?: Type;
+    simplifiedForReading?: Type;
+    simplifiedForWriting?: Type;
+}
+export type TypeVariable = TypeParameter | IndexedAccessType;
+export interface IndexType extends InstantiableType {
+    type: InstantiableType | UnionOrIntersectionType;
+}
+export interface ConditionalRoot {
+    node: ConditionalTypeNode;
+    checkType: Type;
+    extendsType: Type;
+    trueType: Type;
+    falseType: Type;
+    isDistributive: boolean;
+    inferTypeParameters?: TypeParameter[];
+    outerTypeParameters?: TypeParameter[];
+    instantiations?: Map<Type>;
+    aliasSymbol?: Symbol;
+    aliasTypeArguments?: Type[];
+}
+export interface ConditionalType extends InstantiableType {
+    root: ConditionalRoot;
+    checkType: Type;
+    extendsType: Type;
+    resolvedTrueType: Type;
+    resolvedFalseType: Type;
+    resolvedInferredTrueType?: Type;
+    resolvedDefaultConstraint?: Type;
+    mapper?: TypeMapper;
+    combinedMapper?: TypeMapper;
+}
+export interface SubstitutionType extends InstantiableType {
+    baseType: Type;
+    substitute: Type;
+}
+export declare enum JsxReferenceKind {
+    Function = 0,
+    Mixed = 1
+}
+export declare enum SignatureFlags {
+    None = 0,
+    HasRestParameter = 1,// Indicates last parameter is rest parameter
+    HasLiteralTypes = 2,// Indicates signature is specialized
+    IsInnerCallChain = 4,// Indicates signature comes from a CallChain nested in an outer OptionalChain
+    IsOuterCallChain = 8,// Indicates signature comes from a CallChain that is the outermost chain of an optional expression
+    PropagatingFlags = 3,
+    CallChainFlags = 12
+}
+export interface Signature {
+    flags: SignatureFlags;
+    checker?: TypeChecker;
+    declaration?: SignatureDeclaration;
+    typeParameters?: readonly TypeParameter[];
+    parameters: readonly Symbol[];
+    resolvedReturnType?: Type;
+    resolvedTypePredicate?: TypePredicate;
+    minArgumentCount: number;
+    target?: Signature;
+    mapper?: TypeMapper;
+    unionSignatures?: Signature[];
+    erasedSignatureCache?: Signature;
+    canonicalSignatureCache?: Signature;
+    optionalCallSignatureCache?: {
+        inner?: Signature;
+        outer?: Signature;
+    };
+    isolatedSignatureType?: ObjectType;
+    instantiations?: Map<Signature>;
+}
+export declare enum IndexKind {
+    String = 0,
+    Number = 1
+}
+export interface IndexInfo {
+    type: Type;
+    isReadonly: boolean;
+    declaration?: IndexSignatureDeclaration;
+}
+export declare enum TypeMapKind {
+    Simple = 0,
+    Array = 1,
+    Function = 2,
+    Composite = 3,
+    Merged = 4
+}
+export type TypeMapper = {
+    kind: TypeMapKind.Simple;
+    source: Type;
+    target: Type;
+} | {
+    kind: TypeMapKind.Array;
+    sources: readonly Type[];
+    targets: readonly Type[] | undefined;
+} | {
+    kind: TypeMapKind.Function;
+    func: (t: Type) => Type;
+} | {
+    kind: TypeMapKind.Composite | TypeMapKind.Merged;
+    mapper1: TypeMapper;
+    mapper2: TypeMapper;
+};
+export declare enum InferencePriority {
+    None = 0,
+    NakedTypeVariable = 1,// Naked type variable in union or intersection type
+    HomomorphicMappedType = 2,// Reverse inference for homomorphic mapped type
+    PartialHomomorphicMappedType = 4,// Partial reverse inference for homomorphic mapped type
+    MappedTypeConstraint = 8,// Reverse inference for mapped type
+    ContravariantConditional = 16,// Conditional type in contravariant position
+    ReturnType = 32,// Inference made from return type of generic function
+    LiteralKeyof = 64,// Inference made from a string literal to a keyof T
+    NoConstraints = 128,// Don't infer from constraints of instantiable types
+    AlwaysStrict = 256,// Always use strict rules for contravariant inferences
+    MaxValue = 512,// Seed for inference priority tracking
+    PriorityImpliesCombination = 104,// These priorities imply that the resulting type should be a combination of all candidates
+    Circularity = -1
+}
+export interface InferenceInfo {
+    typeParameter: TypeParameter;
+    candidates: Type[] | undefined;
+    contraCandidates: Type[] | undefined;
+    inferredType?: Type;
+    priority?: InferencePriority;
+    topLevel: boolean;
+    isFixed: boolean;
+}
+export declare enum InferenceFlags {
+    None = 0,// No special inference behaviors
+    NoDefault = 1,// Infer unknownType for no inferences (otherwise anyType or emptyObjectType)
+    AnyDefault = 2,// Infer anyType for no inferences (otherwise emptyObjectType)
+    SkippedGenericFunction = 4
+}
+/**
+ * Ternary values are defined such that
+ * x & y is False if either x or y is False.
+ * x & y is Maybe if either x or y is Maybe, but neither x or y is False.
+ * x & y is True if both x and y are True.
+ * x | y is False if both x and y are False.
+ * x | y is Maybe if either x or y is Maybe, but neither x or y is True.
+ * x | y is True if either x or y is True.
+ */
+export declare enum Ternary {
+    False = 0,
+    Maybe = 1,
+    True = -1
+}
+export type TypeComparer = (s: Type, t: Type, reportErrors?: boolean) => Ternary;
+export interface InferenceContext {
+    inferences: InferenceInfo[];
+    signature?: Signature;
+    flags: InferenceFlags;
+    compareTypes: TypeComparer;
+    mapper: TypeMapper;
+    nonFixingMapper: TypeMapper;
+    returnMapper?: TypeMapper;
+    inferredTypeParameters?: readonly TypeParameter[];
+}
+export interface WideningContext {
+    parent?: WideningContext;
+    propertyName?: __String;
+    siblings?: Type[];
+    resolvedProperties?: Symbol[];
+}
+export interface DiagnosticCollection {
+    add(diagnostic: Diagnostic): void;
+    lookup(diagnostic: Diagnostic): Diagnostic | undefined;
+    getGlobalDiagnostics(): Diagnostic[];
+    getDiagnostics(): Diagnostic[];
+    getDiagnostics(fileName: string): DiagnosticWithLocation[];
+    reattachFileDiagnostics(newFile: SourceFile): void;
+}
+export interface CommentDirectivesMap {
+    getUnusedExpectations(): CommentDirective[];
+    markUsed(matchedLine: number): boolean;
+}