@tslite/services 0.0.0-stage → 1.13.0

package/dist/types.d.ts

@@ -0,0 +1,908 @@
+import type { CancellationToken, CheckResult, Declaration, Diagnostic, DiagnosticWithLocation, DocumentHighlights, IntersectionType, LineAndCharacter, LiteralType, Map, NodeArray, NumberLiteralType, ScriptKind, SignatureDeclaration, SourceFile, StringLiteralType, Symbol, SymbolFlags, TextChangeRange, TextRange, TextSpan, TypeFlags, TypeParameter, UnderscoreEscapedMap, UnionOrIntersectionType, UnionType, UserPreferences, __String } from "./_namespaces/ts.js";
+import type { textChanges } from "./_namespaces/edit.js";
+declare module "@tslite/parser" {
+    interface Node {
+        getSourceFile(): SourceFile;
+        getChildCount(sourceFile?: SourceFile): number;
+        getChildAt(index: number, sourceFile?: SourceFile): Node;
+        getChildren(sourceFile?: SourceFileLike): Node[];
+        getStart(sourceFile?: SourceFileLike): number;
+        getFullStart(): number;
+        getEnd(): number;
+        getWidth(sourceFile?: SourceFileLike): number;
+        getFullWidth(): number;
+        getLeadingTriviaWidth(sourceFile?: SourceFile): number;
+        getFullText(sourceFile?: SourceFile): string;
+        getText(sourceFile?: SourceFile): string;
+        getFirstToken(sourceFile?: SourceFileLike): Node | undefined;
+        getLastToken(sourceFile?: SourceFileLike): Node | undefined;
+        forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
+    }
+    interface Identifier {
+        readonly text: string;
+    }
+    interface Symbol {
+        readonly name: string;
+        getFlags(): SymbolFlags;
+        getEscapedName(): __String;
+        getName(): string;
+        getDeclarations(): Declaration[] | undefined;
+    }
+    interface SourceFile {
+        version: string;
+        scriptSnapshot: IScriptSnapshot | undefined;
+        nameTable: UnderscoreEscapedMap<number> | undefined;
+        getNamedDeclarations(): Map<readonly Declaration[]>;
+        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
+        getLineEndOfPosition(pos: number): number;
+        getLineStarts(): readonly number[];
+        getPositionOfLineAndCharacter(line: number, character: number): number;
+        update(newText: string, textChangeRange: TextChangeRange): SourceFile;
+    }
+    interface SourceFileLike {
+        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
+    }
+    interface SourceMapSource {
+        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
+    }
+}
+declare module "@tslite/checker" {
+    interface Type {
+        getFlags(): TypeFlags;
+        getSymbol(): Symbol | undefined;
+        getProperties(): Symbol[];
+        getProperty(propertyName: string): Symbol | undefined;
+        getApparentProperties(): Symbol[];
+        getCallSignatures(): readonly Signature[];
+        getStringIndexType(): Type | undefined;
+        getNumberIndexType(): Type | undefined;
+        getNonNullableType(): Type;
+        getNonOptionalType(): Type;
+        isNullableType(): boolean;
+        getConstraint(): Type | undefined;
+        getDefault(): Type | undefined;
+        isUnion(): this is UnionType;
+        isIntersection(): this is IntersectionType;
+        isUnionOrIntersection(): this is UnionOrIntersectionType;
+        isLiteral(): this is LiteralType;
+        isStringLiteral(): this is StringLiteralType;
+        isNumberLiteral(): this is NumberLiteralType;
+        isTypeParameter(): this is TypeParameter;
+    }
+    interface TypeReference {
+        typeArguments?: readonly Type[];
+    }
+    interface Signature {
+        getDeclaration(): SignatureDeclaration;
+        getTypeParameters(): TypeParameter[] | undefined;
+        getParameters(): Symbol[];
+        getReturnType(): Type;
+    }
+}
+/**
+ * Represents an immutable snapshot of a script at a specified time.Once acquired, the
+ * snapshot is observably immutable. i.e. the same calls with the same parameters will return
+ * the same values.
+ */
+export interface IScriptSnapshot {
+    /** Gets a portion of the script snapshot specified by [start, end). */
+    getText(start: number, end: number): string;
+    /** Gets the length of this script snapshot. */
+    getLength(): number;
+    /**
+     * Gets the TextChangeRange that describe how the text changed between this text and
+     * an older version.  This information is used by the incremental parser to determine
+     * what sections of the script need to be re-parsed.  'undefined' can be returned if the
+     * change range cannot be determined.  However, in that case, incremental parsing will
+     * not happen and the entire document will be re - parsed.
+     */
+    getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
+    /** Releases all resources held by this script snapshot */
+    dispose?(): void;
+}
+export declare namespace ScriptSnapshot {
+    function fromString(text: string): IScriptSnapshot;
+}
+export declare const emptyOptions: {};
+export type WithMetadata<T> = T & {
+    metadata?: unknown;
+};
+export interface HostCancellationToken {
+    isCancellationRequested(): boolean;
+}
+export interface FormattingHost {
+    getNewLine?(): string;
+}
+/**
+ * O host de uma instância do language service: o mundo que ele tipa (CK-47). Os arquivos do programa são os que
+ * `getScriptFileNames` dá, na ordem em que o programa os quer (as libs primeiro, como o `Program` da tag as ordena), e
+ * quem resolve um import é o host (CK-46). Sai da tag o que é do host do `tsc`: as opções (a configuração é fixa, CK-06),
+ * a lib default (o host a põe entre os arquivos), a leitura de disco, as referências de projeto, as diretivas de tipo, os
+ * pacotes de tipos, os transformers e o mapa de fontes.
+ */
+export interface LanguageServiceHost {
+    /** A quebra de linha que o editor prefere, para o texto que a edição escreve sem uma nas opções de formatação. */
+    getNewLine?(): string;
+    getProjectVersion?(): string;
+    getScriptFileNames(): string[];
+    getScriptKind?(fileName: string): ScriptKind;
+    getScriptVersion(fileName: string): string;
+    getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
+    getLocalizedDiagnosticMessages?(): any;
+    getCancellationToken?(): HostCancellationToken;
+    getCurrentDirectory(): string;
+    log?(s: string): void;
+    trace?(s: string): void;
+    error?(s: string): void;
+    useCaseSensitiveFileNames?(): boolean;
+    /**
+     * O arquivo a que o import `moduleName` do arquivo `containingFile` resolve, pelo nome, ou `undefined` se não
+     * resolve (CK-46): o `resolveModule` do `CheckHost`, no lugar do `resolveModuleNames` da tag.
+     */
+    resolveModule(moduleName: string, containingFile: string): string | undefined;
+}
+export interface LanguageService {
+    /** This is used as a part of restarting the language service. */
+    cleanupSemanticCache(): void;
+    /**
+     * Gets errors indicating invalid syntax in a file.
+     *
+     * In English, "this cdeo have, erorrs" is syntactically invalid because it has typos,
+     * grammatical errors, and misplaced punctuation. Likewise, examples of syntax
+     * errors in TypeScript are missing parentheses in an `if` statement, mismatched
+     * curly braces, and using a reserved keyword as a variable name.
+     *
+     * These diagnostics are inexpensive to compute and don't require knowledge of
+     * other files. Note that a non-empty result increases the likelihood of false positives
+     * from `getSemanticDiagnostics`.
+     *
+     * While these represent the majority of syntax-related diagnostics, there are some
+     * that require the type system, which will be present in `getSemanticDiagnostics`.
+     *
+     * @param fileName A path to the file you want syntactic diagnostics for
+     */
+    getSyntacticDiagnostics(fileName: string): DiagnosticWithLocation[];
+    /**
+     * Gets warnings or errors indicating type system issues in a given file.
+     * Requesting semantic diagnostics may start up the type system and
+     * run deferred work, so the first call may take longer than subsequent calls.
+     *
+     * Unlike the other get*Diagnostics functions, these diagnostics can potentially not
+     * include a reference to a source file. Specifically, the first time this is called,
+     * it will return global diagnostics with no associated location.
+     *
+     * To contrast the differences between semantic and syntactic diagnostics, consider the
+     * sentence: "The sun is green." is syntactically correct; those are real English words with
+     * correct sentence structure. However, it is semantically invalid, because it is not true.
+     *
+     * @param fileName A path to the file you want semantic diagnostics for
+     */
+    getSemanticDiagnostics(fileName: string): Diagnostic[];
+    /**
+     * Gets suggestion diagnostics for a specific file. These diagnostics tend to
+     * proactively suggest refactors, as opposed to diagnostics that indicate
+     * potentially incorrect runtime behavior.
+     *
+     * @param fileName A path to the file you want semantic diagnostics for
+     */
+    getSuggestionDiagnostics(fileName: string): DiagnosticWithLocation[];
+    /** @deprecated Use getEncodedSyntacticClassifications instead. */
+    getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+    /** @deprecated Use getEncodedSemanticClassifications instead. */
+    getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+    getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications;
+    getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications;
+    /**
+     * Gets completion entries at a particular position in a file.
+     *
+     * @param fileName The path to the file
+     * @param position A zero-based index of the character where you want the entries
+     * @param options An object describing how the request was triggered and what kinds
+     * of code actions can be returned with the completions.
+     */
+    getCompletionsAtPosition(fileName: string, position: number, options: GetCompletionsAtPositionOptions | undefined): WithMetadata<CompletionInfo> | undefined;
+    /**
+     * Gets the extended details for a completion entry retrieved from `getCompletionsAtPosition`.
+     *
+     * @param fileName The path to the file
+     * @param position A zero based index of the character where you want the entries
+     * @param entryName The name from an existing completion which came from `getCompletionsAtPosition`
+     * @param formatOptions How should code samples in the completions be formatted, can be undefined for backwards compatibility
+     * @param source Source code for the current file, can be undefined for backwards compatibility
+     * @param preferences User settings, can be undefined for backwards compatibility
+     */
+    getCompletionEntryDetails(fileName: string, position: number, entryName: string, formatOptions: FormatCodeSettings | undefined, source: string | undefined, preferences: UserPreferences | undefined): CompletionEntryDetails | undefined;
+    getCompletionEntrySymbol(fileName: string, position: number, name: string, source: string | undefined): Symbol | undefined;
+    /**
+     * Gets semantic information about the identifier at a particular position in a
+     * file. Quick info is what you typically see when you hover in an editor.
+     *
+     * @param fileName The path to the file
+     * @param position A zero-based index of the character where you want the quick info
+     */
+    getQuickInfoAtPosition(fileName: string, position: number): QuickInfo | undefined;
+    getSignatureHelpItems(fileName: string, position: number, options: SignatureHelpItemsOptions | undefined): SignatureHelpItems | undefined;
+    getRenameInfo(fileName: string, position: number, options?: RenameInfoOptions): RenameInfo;
+    findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean, providePrefixAndSuffixTextForRename?: boolean): readonly RenameLocation[] | undefined;
+    getSmartSelectionRange(fileName: string, position: number): SelectionRange;
+    getDefinitionAtPosition(fileName: string, position: number): readonly DefinitionInfo[] | undefined;
+    getDefinitionAndBoundSpan(fileName: string, position: number): DefinitionInfoAndBoundSpan | undefined;
+    getTypeDefinitionAtPosition(fileName: string, position: number): readonly DefinitionInfo[] | undefined;
+    getImplementationAtPosition(fileName: string, position: number): readonly ImplementationLocation[] | undefined;
+    getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] | undefined;
+    findReferences(fileName: string, position: number): ReferencedSymbol[] | undefined;
+    getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[] | undefined;
+    /** @deprecated */
+    getOccurrencesAtPosition(fileName: string, position: number): readonly ReferenceEntry[] | undefined;
+    getNavigationBarItems(fileName: string): NavigationBarItem[];
+    getNavigationTree(fileName: string): NavigationTree;
+    getOutliningSpans(fileName: string): OutliningSpan[];
+    getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
+    getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
+    getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
+    getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
+    getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
+    getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
+    isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
+    /**
+     * This will return a defined result if the position is after the `>` of the opening tag, or somewhere in the text, of a JSXElement with no closing tag.
+     * Editors should call this after `>` is typed.
+     */
+    getJsxClosingTagAtPosition(fileName: string, position: number): JsxClosingTagInfo | undefined;
+    getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): TextSpan | undefined;
+    getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: readonly number[], formatOptions: FormatCodeSettings, preferences: UserPreferences): readonly CodeFixAction[];
+    getCombinedCodeFix(scope: CombinedCodeFixScope, fixId: {}, formatOptions: FormatCodeSettings, preferences: UserPreferences): CombinedCodeActions;
+    getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined): ApplicableRefactorInfo[];
+    getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string, preferences: UserPreferences | undefined): RefactorEditInfo | undefined;
+    organizeImports(scope: OrganizeImportsScope, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
+    getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
+    /** O programa ligado e tipado da foto atual do host: o resultado do `check` da cópia, no lugar do `Program`. */
+    getProgram(): CheckResult | undefined;
+    dispose(): void;
+}
+export interface JsxClosingTagInfo {
+    readonly newText: string;
+}
+export interface CombinedCodeFixScope {
+    type: "file";
+    fileName: string;
+}
+export type OrganizeImportsScope = CombinedCodeFixScope;
+export type CompletionsTriggerCharacter = "." | '"' | "'" | "`" | "/" | "@" | "<" | "#";
+export interface GetCompletionsAtPositionOptions extends UserPreferences {
+    /**
+     * If the editor is asking for completions because a certain character was typed
+     * (as opposed to when the user explicitly requested them) this should be set.
+     */
+    triggerCharacter?: CompletionsTriggerCharacter;
+    /** @deprecated Use includeCompletionsForModuleExports */
+    includeExternalModuleExports?: boolean;
+    /** @deprecated Use includeCompletionsWithInsertText */
+    includeInsertTextCompletions?: boolean;
+}
+export type SignatureHelpTriggerCharacter = "," | "(" | "<";
+export type SignatureHelpRetriggerCharacter = SignatureHelpTriggerCharacter | ")";
+export interface SignatureHelpItemsOptions {
+    triggerReason?: SignatureHelpTriggerReason;
+}
+export type SignatureHelpTriggerReason = SignatureHelpInvokedReason | SignatureHelpCharacterTypedReason | SignatureHelpRetriggeredReason;
+/**
+ * Signals that the user manually requested signature help.
+ * The language service will unconditionally attempt to provide a result.
+ */
+export interface SignatureHelpInvokedReason {
+    kind: "invoked";
+    triggerCharacter?: undefined;
+}
+/**
+ * Signals that the signature help request came from a user typing a character.
+ * Depending on the character and the syntactic context, the request may or may not be served a result.
+ */
+export interface SignatureHelpCharacterTypedReason {
+    kind: "characterTyped";
+    /**
+     * Character that was responsible for triggering signature help.
+     */
+    triggerCharacter: SignatureHelpTriggerCharacter;
+}
+/**
+ * Signals that this signature help request came from typing a character or moving the cursor.
+ * This should only occur if a signature help session was already active and the editor needs to see if it should adjust.
+ * The language service will unconditionally attempt to provide a result.
+ * `triggerCharacter` can be `undefined` for a retrigger caused by a cursor move.
+ */
+export interface SignatureHelpRetriggeredReason {
+    kind: "retrigger";
+    /**
+     * Character that was responsible for triggering signature help.
+     */
+    triggerCharacter?: SignatureHelpRetriggerCharacter;
+}
+export interface Classifications {
+    spans: number[];
+    endOfLineState: EndOfLineState;
+}
+export interface ClassifiedSpan {
+    textSpan: TextSpan;
+    classificationType: ClassificationTypeNames;
+}
+export interface NavigationBarItem {
+    text: string;
+    kind: ScriptElementKind;
+    kindModifiers: string;
+    spans: TextSpan[];
+    childItems: NavigationBarItem[];
+    indent: number;
+    bolded: boolean;
+    grayed: boolean;
+}
+/**
+ * Node in a tree of nested declarations in a file.
+ * The top node is always a script or module node.
+ */
+export interface NavigationTree {
+    /** Name of the declaration, or a short description, e.g. "<class>". */
+    text: string;
+    kind: ScriptElementKind;
+    /** ScriptElementKindModifier separated by commas, e.g. "public,abstract" */
+    kindModifiers: string;
+    /**
+     * Spans of the nodes that generated this declaration.
+     * There will be more than one if this is the result of merging.
+     */
+    spans: TextSpan[];
+    nameSpan: TextSpan | undefined;
+    /** Present if non-empty */
+    childItems?: NavigationTree[];
+}
+export interface TodoCommentDescriptor {
+    text: string;
+    priority: number;
+}
+export interface TodoComment {
+    descriptor: TodoCommentDescriptor;
+    message: string;
+    position: number;
+}
+export interface TextChange {
+    span: TextSpan;
+    newText: string;
+}
+export interface FileTextChanges {
+    fileName: string;
+    textChanges: readonly TextChange[];
+    isNewFile?: boolean;
+}
+export interface CodeAction {
+    /** Description of the code action to display in the UI of the editor */
+    description: string;
+    /** Text changes to apply to each file as part of the code action */
+    changes: FileTextChanges[];
+}
+export interface CodeFixAction extends CodeAction {
+    /** Short name to identify the fix, for use by telemetry. */
+    fixName: string;
+    /**
+     * If present, one may call 'getCombinedCodeFix' with this fixId.
+     * This may be omitted to indicate that the code fix can't be applied in a group.
+     */
+    fixId?: {};
+    fixAllDescription?: string;
+}
+export interface CombinedCodeActions {
+    changes: readonly FileTextChanges[];
+}
+/**
+ * A set of one or more available refactoring actions, grouped under a parent refactoring.
+ */
+export interface ApplicableRefactorInfo {
+    /**
+     * The programmatic name of the refactoring
+     */
+    name: string;
+    /**
+     * A description of this refactoring category to show to the user.
+     * If the refactoring gets inlined (see below), this text will not be visible.
+     */
+    description: string;
+    /**
+     * Inlineable refactorings can have their actions hoisted out to the top level
+     * of a context menu. Non-inlineanable refactorings should always be shown inside
+     * their parent grouping.
+     *
+     * If not specified, this value is assumed to be 'true'
+     */
+    inlineable?: boolean;
+    actions: RefactorActionInfo[];
+}
+/**
+ * Represents a single refactoring action - for example, the "Extract Method..." refactor might
+ * offer several actions, each corresponding to a surround class or closure to extract into.
+ */
+export interface RefactorActionInfo {
+    /**
+     * The programmatic name of the refactoring action
+     */
+    name: string;
+    /**
+     * A description of this refactoring action to show to the user.
+     * If the parent refactoring is inlined away, this will be the only text shown,
+     * so this description should make sense by itself if the parent is inlineable=true
+     */
+    description: string;
+}
+/**
+ * As edições de um refactor, e o lugar de onde o editor começa um rename do nome que ele criou. Na tag, também o
+ * `commands`, o pedido ao host de instalar um pacote de tipos (CK-47).
+ */
+export interface RefactorEditInfo {
+    edits: FileTextChanges[];
+    renameFilename?: string;
+    renameLocation?: number;
+}
+/**
+ * Um trecho de um arquivo. O `contextSpan` é o da declaração inteira, quando o `textSpan` é o nome dela. Na tag, também
+ * o trecho original de um arquivo mapeado (o `.d.ts.map`), que é do host.
+ */
+export interface DocumentSpan {
+    textSpan: TextSpan;
+    fileName: string;
+    contextSpan?: TextSpan;
+}
+export interface RenameLocation extends DocumentSpan {
+    readonly prefixText?: string;
+    readonly suffixText?: string;
+}
+export interface ReferenceEntry extends DocumentSpan {
+    isWriteAccess: boolean;
+    isDefinition: boolean;
+    isInString?: true;
+}
+export interface ImplementationLocation extends DocumentSpan {
+    kind: ScriptElementKind;
+    displayParts: SymbolDisplayPart[];
+}
+export declare enum HighlightSpanKind {
+    none = "none",
+    definition = "definition",
+    reference = "reference",
+    writtenReference = "writtenReference"
+}
+export interface HighlightSpan {
+    fileName?: string;
+    isInString?: true;
+    textSpan: TextSpan;
+    contextSpan?: TextSpan;
+    kind: HighlightSpanKind;
+}
+export declare enum IndentStyle {
+    None = 0,
+    Block = 1,
+    Smart = 2
+}
+export declare enum SemicolonPreference {
+    Ignore = "ignore",
+    Insert = "insert",
+    Remove = "remove"
+}
+export interface EditorOptions {
+    BaseIndentSize?: number;
+    IndentSize: number;
+    TabSize: number;
+    NewLineCharacter: string;
+    ConvertTabsToSpaces: boolean;
+    IndentStyle: IndentStyle;
+}
+export interface EditorSettings {
+    baseIndentSize?: number;
+    indentSize?: number;
+    tabSize?: number;
+    newLineCharacter?: string;
+    convertTabsToSpaces?: boolean;
+    indentStyle?: IndentStyle;
+    trimTrailingWhitespace?: boolean;
+}
+export interface FormatCodeOptions extends EditorOptions {
+    InsertSpaceAfterCommaDelimiter: boolean;
+    InsertSpaceAfterSemicolonInForStatements: boolean;
+    InsertSpaceBeforeAndAfterBinaryOperators: boolean;
+    InsertSpaceAfterConstructor?: boolean;
+    InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
+    InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
+    InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
+    InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
+    InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
+    InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
+    InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
+    InsertSpaceAfterTypeAssertion?: boolean;
+    InsertSpaceBeforeFunctionParenthesis?: boolean;
+    PlaceOpenBraceOnNewLineForFunctions: boolean;
+    PlaceOpenBraceOnNewLineForControlBlocks: boolean;
+    insertSpaceBeforeTypeAnnotation?: boolean;
+}
+export interface FormatCodeSettings extends EditorSettings {
+    readonly insertSpaceAfterCommaDelimiter?: boolean;
+    readonly insertSpaceAfterSemicolonInForStatements?: boolean;
+    readonly insertSpaceBeforeAndAfterBinaryOperators?: boolean;
+    readonly insertSpaceAfterConstructor?: boolean;
+    readonly insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
+    readonly insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
+    readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
+    readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
+    readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
+    readonly insertSpaceAfterOpeningAndBeforeClosingEmptyBraces?: boolean;
+    readonly insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
+    readonly insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
+    readonly insertSpaceAfterTypeAssertion?: boolean;
+    readonly insertSpaceBeforeFunctionParenthesis?: boolean;
+    readonly placeOpenBraceOnNewLineForFunctions?: boolean;
+    readonly placeOpenBraceOnNewLineForControlBlocks?: boolean;
+    readonly insertSpaceBeforeTypeAnnotation?: boolean;
+    readonly indentMultiLineObjectLiteralBeginningOnBlankLine?: boolean;
+    readonly semicolons?: SemicolonPreference;
+}
+export declare function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings;
+export interface DefinitionInfo extends DocumentSpan {
+    kind: ScriptElementKind;
+    name: string;
+    containerKind: ScriptElementKind;
+    containerName: string;
+    isLocal?: boolean;
+}
+export interface DefinitionInfoAndBoundSpan {
+    definitions?: readonly DefinitionInfo[];
+    textSpan: TextSpan;
+}
+export interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
+    displayParts: SymbolDisplayPart[];
+}
+export interface ReferencedSymbol {
+    definition: ReferencedSymbolDefinitionInfo;
+    references: ReferenceEntry[];
+}
+export declare enum SymbolDisplayPartKind {
+    aliasName = 0,
+    className = 1,
+    enumName = 2,
+    fieldName = 3,
+    interfaceName = 4,
+    keyword = 5,
+    lineBreak = 6,
+    numericLiteral = 7,
+    stringLiteral = 8,
+    localName = 9,
+    methodName = 10,
+    moduleName = 11,
+    operator = 12,
+    parameterName = 13,
+    propertyName = 14,
+    punctuation = 15,
+    space = 16,
+    text = 17,
+    typeParameterName = 18,
+    enumMemberName = 19,
+    functionName = 20,
+    regularExpressionLiteral = 21
+}
+export interface SymbolDisplayPart {
+    text: string;
+    kind: string;
+}
+export interface JSDocTagInfo {
+    name: string;
+    text?: string;
+}
+export interface QuickInfo {
+    kind: ScriptElementKind;
+    kindModifiers: string;
+    textSpan: TextSpan;
+    displayParts?: SymbolDisplayPart[];
+    documentation?: SymbolDisplayPart[];
+    tags?: JSDocTagInfo[];
+}
+export type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
+export interface RenameInfoSuccess {
+    canRename: true;
+    /**
+     * File or directory to rename.
+     * If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
+     */
+    fileToRename?: string;
+    displayName: string;
+    fullDisplayName: string;
+    kind: ScriptElementKind;
+    kindModifiers: string;
+    triggerSpan: TextSpan;
+}
+export interface RenameInfoFailure {
+    canRename: false;
+    localizedErrorMessage: string;
+}
+export interface RenameInfoOptions {
+    readonly allowRenameOfImportPath?: boolean;
+}
+export interface SignatureHelpParameter {
+    name: string;
+    documentation: SymbolDisplayPart[];
+    displayParts: SymbolDisplayPart[];
+    isOptional: boolean;
+}
+export interface SelectionRange {
+    textSpan: TextSpan;
+    parent?: SelectionRange;
+}
+/**
+ * Represents a single signature to show in signature help.
+ * The id is used for subsequent calls into the language service to ask questions about the
+ * signature help item in the context of any documents that have been updated.  i.e. after
+ * an edit has happened, while signature help is still active, the host can ask important
+ * questions like 'what parameter is the user currently contained within?'.
+ */
+export interface SignatureHelpItem {
+    isVariadic: boolean;
+    prefixDisplayParts: SymbolDisplayPart[];
+    suffixDisplayParts: SymbolDisplayPart[];
+    separatorDisplayParts: SymbolDisplayPart[];
+    parameters: SignatureHelpParameter[];
+    documentation: SymbolDisplayPart[];
+    tags: JSDocTagInfo[];
+}
+/**
+ * Represents a set of signature help items, and the preferred item that should be selected.
+ */
+export interface SignatureHelpItems {
+    items: SignatureHelpItem[];
+    applicableSpan: TextSpan;
+    selectedItemIndex: number;
+    argumentIndex: number;
+    argumentCount: number;
+}
+export interface CompletionInfo {
+    /** Not true for all global completions. This will be true if the enclosing scope matches a few syntax kinds. See `isSnippetScope`. */
+    isGlobalCompletion: boolean;
+    isMemberCompletion: boolean;
+    /**
+     * true when the current location also allows for a new identifier
+     */
+    isNewIdentifierLocation: boolean;
+    entries: CompletionEntry[];
+}
+export interface CompletionEntry {
+    name: string;
+    kind: ScriptElementKind;
+    kindModifiers?: string;
+    sortText: string;
+    insertText?: string;
+    /**
+     * An optional span that indicates the text to be replaced by this completion item.
+     * If present, this span should be used instead of the default one.
+     * It will be set if the required span differs from the one generated by the default replacement behavior.
+     */
+    replacementSpan?: TextSpan;
+    hasAction?: true;
+    source?: string;
+}
+export interface CompletionEntryDetails {
+    name: string;
+    kind: ScriptElementKind;
+    kindModifiers: string;
+    displayParts: SymbolDisplayPart[];
+    documentation?: SymbolDisplayPart[];
+    tags?: JSDocTagInfo[];
+    codeActions?: CodeAction[];
+    source?: SymbolDisplayPart[];
+}
+export interface OutliningSpan {
+    /** The span of the document to actually collapse. */
+    textSpan: TextSpan;
+    /** The span of the document to display when the user hovers over the collapsed span. */
+    hintSpan: TextSpan;
+    /** The text to display in the editor for the collapsed region. */
+    bannerText: string;
+    /**
+     * Whether or not this region should be automatically collapsed when
+     * the 'Collapse to Definitions' command is invoked.
+     */
+    autoCollapse: boolean;
+    /**
+     * Classification of the contents of the span
+     */
+    kind: OutliningSpanKind;
+}
+export declare enum OutliningSpanKind {
+    /** Single or multi-line comments */
+    Comment = "comment",
+    /** Sections marked by '// #region' and '// #endregion' comments */
+    Region = "region",
+    /** Declarations and expressions */
+    Code = "code",
+    /** Contiguous blocks of import declarations */
+    Imports = "imports"
+}
+export declare enum ScriptElementKind {
+    unknown = "",
+    warning = "warning",
+    /** predefined type (void) or keyword (class) */
+    keyword = "keyword",
+    /** top level script node */
+    scriptElement = "script",
+    /** module foo {} */
+    moduleElement = "module",
+    /** class X {} */
+    classElement = "class",
+    /** var x = class X {} */
+    localClassElement = "local class",
+    /** interface Y {} */
+    interfaceElement = "interface",
+    /** type T = ... */
+    typeElement = "type",
+    /** enum E */
+    enumElement = "enum",
+    enumMemberElement = "enum member",
+    /**
+     * Inside module and script only
+     * const v = ..
+     */
+    variableElement = "var",
+    /** Inside function */
+    localVariableElement = "local var",
+    /**
+     * Inside module and script only
+     * function f() { }
+     */
+    functionElement = "function",
+    /** Inside function */
+    localFunctionElement = "local function",
+    /** class X { [public|private]* foo() {} } */
+    memberFunctionElement = "method",
+    /** class X { [public|private]* [get|set] foo:number; } */
+    memberGetAccessorElement = "getter",
+    memberSetAccessorElement = "setter",
+    /**
+     * class X { [public|private]* foo:number; }
+     * interface Y { foo:number; }
+     */
+    memberVariableElement = "property",
+    /** class X { constructor() { } } */
+    constructorImplementationElement = "constructor",
+    /** interface Y { ():number; } */
+    callSignatureElement = "call",
+    /** interface Y { []:number; } */
+    indexSignatureElement = "index",
+    /** interface Y { new():Y; } */
+    constructSignatureElement = "construct",
+    /** function foo(*Y*: string) */
+    parameterElement = "parameter",
+    typeParameterElement = "type parameter",
+    primitiveType = "primitive type",
+    label = "label",
+    alias = "alias",
+    constElement = "const",
+    letElement = "let",
+    directory = "directory",
+    externalModuleName = "external module name",
+    /**
+     * <JsxTagName attribute1 attribute2={0} />
+     */
+    jsxAttribute = "JSX attribute",
+    /** String literal */
+    string = "string"
+}
+export declare enum ScriptElementKindModifier {
+    none = "",
+    publicMemberModifier = "public",
+    privateMemberModifier = "private",
+    protectedMemberModifier = "protected",
+    exportedModifier = "export",
+    ambientModifier = "declare",
+    staticModifier = "static",
+    abstractModifier = "abstract",
+    optionalModifier = "optional",
+    dtsModifier = ".d.ts",
+    tsModifier = ".ts",
+    tsxModifier = ".tsx",
+    jsModifier = ".js",
+    jsxModifier = ".jsx",
+    jsonModifier = ".json"
+}
+export declare enum EndOfLineState {
+    None = 0,
+    InMultiLineCommentTrivia = 1,
+    InSingleQuoteStringLiteral = 2,
+    InDoubleQuoteStringLiteral = 3,
+    InTemplateHeadOrNoSubstitutionTemplate = 4,
+    InTemplateMiddleOrTail = 5,
+    InTemplateSubstitutionPosition = 6
+}
+export declare enum ClassificationTypeNames {
+    comment = "comment",
+    identifier = "identifier",
+    keyword = "keyword",
+    numericLiteral = "number",
+    bigintLiteral = "bigint",
+    operator = "operator",
+    stringLiteral = "string",
+    whiteSpace = "whitespace",
+    text = "text",
+    punctuation = "punctuation",
+    className = "class name",
+    enumName = "enum name",
+    interfaceName = "interface name",
+    moduleName = "module name",
+    typeParameterName = "type parameter name",
+    typeAliasName = "type alias name",
+    parameterName = "parameter name",
+    docCommentTagName = "doc comment tag name",
+    jsxOpenTagName = "jsx open tag name",
+    jsxCloseTagName = "jsx close tag name",
+    jsxSelfClosingTagName = "jsx self closing tag name",
+    jsxAttribute = "jsx attribute",
+    jsxText = "jsx text",
+    jsxAttributeStringLiteralValue = "jsx attribute string literal value"
+}
+/**
+ * O tipo de um trecho na classificação codificada. Os valores são o protocolo com o editor, como na tag: os que a
+ * Linguagem não produz (a classe, o enum, a regex, a tag do JSDoc) ficam, sem renumerar os outros.
+ */
+export declare enum ClassificationType {
+    comment = 1,
+    identifier = 2,
+    keyword = 3,
+    numericLiteral = 4,
+    operator = 5,
+    stringLiteral = 6,
+    regularExpressionLiteral = 7,
+    whiteSpace = 8,
+    text = 9,
+    punctuation = 10,
+    className = 11,
+    enumName = 12,
+    interfaceName = 13,
+    moduleName = 14,
+    typeParameterName = 15,
+    typeAliasName = 16,
+    parameterName = 17,
+    docCommentTagName = 18,
+    jsxOpenTagName = 19,
+    jsxCloseTagName = 20,
+    jsxSelfClosingTagName = 21,
+    jsxAttribute = 22,
+    jsxText = 23,
+    jsxAttributeStringLiteralValue = 24,
+    bigintLiteral = 25
+}
+export interface CodeFixRegistration {
+    errorCodes: readonly number[];
+    getCodeActions(context: CodeFixContext): CodeFixAction[] | undefined;
+    fixIds?: readonly string[];
+    getAllCodeActions?(context: CodeFixAllContext): CombinedCodeActions;
+}
+/** O contexto de um code fix. O `program` é o resultado do `check` da cópia, no lugar do `Program` da tag. */
+export interface CodeFixContextBase extends textChanges.TextChangesContext {
+    sourceFile: SourceFile;
+    program: CheckResult;
+    cancellationToken: CancellationToken;
+    preferences: UserPreferences;
+}
+export interface CodeFixAllContext extends CodeFixContextBase {
+    fixId: {};
+}
+export interface CodeFixContext extends CodeFixContextBase {
+    errorCode: number;
+    span: TextSpan;
+}
+export interface Refactor {
+    /** Compute the associated code actions */
+    getEditsForAction(context: RefactorContext, actionName: string): RefactorEditInfo | undefined;
+    /** Compute (quickly) which actions are available here */
+    getAvailableActions(context: RefactorContext): readonly ApplicableRefactorInfo[];
+}
+/** O contexto de um refactor. O `program` é o resultado do `check` da cópia, no lugar do `Program` da tag. */
+export interface RefactorContext extends textChanges.TextChangesContext {
+    file: SourceFile;
+    startPosition: number;
+    endPosition?: number;
+    program: CheckResult;
+    cancellationToken?: CancellationToken;
+    preferences: UserPreferences;
+}