/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
///
declare namespace ts {
namespace server {
namespace protocol {
export import ApplicableRefactorInfo = ts.ApplicableRefactorInfo;
export import ClassificationType = ts.ClassificationType;
export import CompletionsTriggerCharacter = ts.CompletionsTriggerCharacter;
export import CompletionTriggerKind = ts.CompletionTriggerKind;
export import InlayHintKind = ts.InlayHintKind;
export import OrganizeImportsMode = ts.OrganizeImportsMode;
export import RefactorActionInfo = ts.RefactorActionInfo;
export import RefactorTriggerReason = ts.RefactorTriggerReason;
export import RenameInfoFailure = ts.RenameInfoFailure;
export import SemicolonPreference = ts.SemicolonPreference;
export import SignatureHelpCharacterTypedReason = ts.SignatureHelpCharacterTypedReason;
export import SignatureHelpInvokedReason = ts.SignatureHelpInvokedReason;
export import SignatureHelpParameter = ts.SignatureHelpParameter;
export import SignatureHelpRetriggerCharacter = ts.SignatureHelpRetriggerCharacter;
export import SignatureHelpRetriggeredReason = ts.SignatureHelpRetriggeredReason;
export import SignatureHelpTriggerCharacter = ts.SignatureHelpTriggerCharacter;
export import SignatureHelpTriggerReason = ts.SignatureHelpTriggerReason;
export import SymbolDisplayPart = ts.SymbolDisplayPart;
export import UserPreferences = ts.UserPreferences;
type ChangePropertyTypes<
T,
Substitutions extends {
[K in keyof T]?: any;
},
> = {
[K in keyof T]: K extends keyof Substitutions ? Substitutions[K] : T[K];
};
type ChangeStringIndexSignature = {
[K in keyof T]: string extends K ? NewStringIndexSignatureType : T[K];
};
export enum CommandTypes {
JsxClosingTag = "jsxClosingTag",
LinkedEditingRange = "linkedEditingRange",
Brace = "brace",
BraceCompletion = "braceCompletion",
GetSpanOfEnclosingComment = "getSpanOfEnclosingComment",
Change = "change",
Close = "close",
/** @deprecated Prefer CompletionInfo -- see comment on CompletionsResponse */
Completions = "completions",
CompletionInfo = "completionInfo",
CompletionDetails = "completionEntryDetails",
CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList",
CompileOnSaveEmitFile = "compileOnSaveEmitFile",
Configure = "configure",
Definition = "definition",
DefinitionAndBoundSpan = "definitionAndBoundSpan",
Implementation = "implementation",
Exit = "exit",
FileReferences = "fileReferences",
Format = "format",
Formatonkey = "formatonkey",
Geterr = "geterr",
GeterrForProject = "geterrForProject",
SemanticDiagnosticsSync = "semanticDiagnosticsSync",
SyntacticDiagnosticsSync = "syntacticDiagnosticsSync",
SuggestionDiagnosticsSync = "suggestionDiagnosticsSync",
NavBar = "navbar",
Navto = "navto",
NavTree = "navtree",
NavTreeFull = "navtree-full",
DocumentHighlights = "documentHighlights",
Open = "open",
Quickinfo = "quickinfo",
References = "references",
Reload = "reload",
Rename = "rename",
Saveto = "saveto",
SignatureHelp = "signatureHelp",
FindSourceDefinition = "findSourceDefinition",
Status = "status",
TypeDefinition = "typeDefinition",
ProjectInfo = "projectInfo",
ReloadProjects = "reloadProjects",
Unknown = "unknown",
OpenExternalProject = "openExternalProject",
OpenExternalProjects = "openExternalProjects",
CloseExternalProject = "closeExternalProject",
UpdateOpen = "updateOpen",
GetOutliningSpans = "getOutliningSpans",
TodoComments = "todoComments",
Indentation = "indentation",
DocCommentTemplate = "docCommentTemplate",
CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects",
GetCodeFixes = "getCodeFixes",
GetCombinedCodeFix = "getCombinedCodeFix",
ApplyCodeActionCommand = "applyCodeActionCommand",
GetSupportedCodeFixes = "getSupportedCodeFixes",
GetApplicableRefactors = "getApplicableRefactors",
GetEditsForRefactor = "getEditsForRefactor",
GetMoveToRefactoringFileSuggestions = "getMoveToRefactoringFileSuggestions",
PreparePasteEdits = "preparePasteEdits",
GetPasteEdits = "getPasteEdits",
OrganizeImports = "organizeImports",
GetEditsForFileRename = "getEditsForFileRename",
ConfigurePlugin = "configurePlugin",
SelectionRange = "selectionRange",
ToggleLineComment = "toggleLineComment",
ToggleMultilineComment = "toggleMultilineComment",
CommentSelection = "commentSelection",
UncommentSelection = "uncommentSelection",
PrepareCallHierarchy = "prepareCallHierarchy",
ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls",
ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls",
ProvideInlayHints = "provideInlayHints",
WatchChange = "watchChange",
MapCode = "mapCode",
}
/**
* A TypeScript Server message
*/
export interface Message {
/**
* Sequence number of the message
*/
seq: number;
/**
* One of "request", "response", or "event"
*/
type: "request" | "response" | "event";
}
/**
* Client-initiated request message
*/
export interface Request extends Message {
type: "request";
/**
* The command to execute
*/
command: string;
/**
* Object containing arguments for the command
*/
arguments?: any;
}
/**
* Request to reload the project structure for all the opened files
*/
export interface ReloadProjectsRequest extends Request {
command: CommandTypes.ReloadProjects;
}
/**
* Server-initiated event message
*/
export interface Event extends Message {
type: "event";
/**
* Name of event
*/
event: string;
/**
* Event-specific information
*/
body?: any;
}
/**
* Response by server to client request message.
*/
export interface Response extends Message {
type: "response";
/**
* Sequence number of the request message.
*/
request_seq: number;
/**
* Outcome of the request.
*/
success: boolean;
/**
* The command requested.
*/
command: string;
/**
* If success === false, this should always be provided.
* Otherwise, may (or may not) contain a success message.
*/
message?: string;
/**
* Contains message body if success === true.
*/
body?: any;
/**
* Contains extra information that plugin can include to be passed on
*/
metadata?: unknown;
/**
* Exposes information about the performance of this request-response pair.
*/
performanceData?: PerformanceData;
}
export interface PerformanceData {
/**
* Time spent updating the program graph, in milliseconds.
*/
updateGraphDurationMs?: number;
/**
* The time spent creating or updating the auto-import program, in milliseconds.
*/
createAutoImportProviderProgramDurationMs?: number;
/**
* The time spent computing diagnostics, in milliseconds.
*/
diagnosticsDuration?: FileDiagnosticPerformanceData[];
}
/**
* Time spent computing each kind of diagnostics, in milliseconds.
*/
export type DiagnosticPerformanceData = {
[Kind in DiagnosticEventKind]?: number;
};
export interface FileDiagnosticPerformanceData extends DiagnosticPerformanceData {
/**
* The file for which the performance data is reported.
*/
file: string;
}
/**
* Arguments for FileRequest messages.
*/
export interface FileRequestArgs {
/**
* The file for the request (absolute pathname required).
*/
file: string;
projectFileName?: string;
}
export interface StatusRequest extends Request {
command: CommandTypes.Status;
}
export interface StatusResponseBody {
/**
* The TypeScript version (`ts.version`).
*/
version: string;
}
/**
* Response to StatusRequest
*/
export interface StatusResponse extends Response {
body: StatusResponseBody;
}
/**
* Requests a JS Doc comment template for a given position
*/
export interface DocCommentTemplateRequest extends FileLocationRequest {
command: CommandTypes.DocCommentTemplate;
}
/**
* Response to DocCommentTemplateRequest
*/
export interface DocCommandTemplateResponse extends Response {
body?: TextInsertion;
}
/**
* A request to get TODO comments from the file
*/
export interface TodoCommentRequest extends FileRequest {
command: CommandTypes.TodoComments;
arguments: TodoCommentRequestArgs;
}
/**
* Arguments for TodoCommentRequest request.
*/
export interface TodoCommentRequestArgs extends FileRequestArgs {
/**
* Array of target TodoCommentDescriptors that describes TODO comments to be found
*/
descriptors: TodoCommentDescriptor[];
}
/**
* Response for TodoCommentRequest request.
*/
export interface TodoCommentsResponse extends Response {
body?: TodoComment[];
}
/**
* A request to determine if the caret is inside a comment.
*/
export interface SpanOfEnclosingCommentRequest extends FileLocationRequest {
command: CommandTypes.GetSpanOfEnclosingComment;
arguments: SpanOfEnclosingCommentRequestArgs;
}
export interface SpanOfEnclosingCommentRequestArgs extends FileLocationRequestArgs {
/**
* Requires that the enclosing span be a multi-line comment, or else the request returns undefined.
*/
onlyMultiLine: boolean;
}
/**
* Request to obtain outlining spans in file.
*/
export interface OutliningSpansRequest extends FileRequest {
command: CommandTypes.GetOutliningSpans;
}
export type OutliningSpan = ChangePropertyTypes;
/**
* Response to OutliningSpansRequest request.
*/
export interface OutliningSpansResponse extends Response {
body?: OutliningSpan[];
}
/**
* A request to get indentation for a location in file
*/
export interface IndentationRequest extends FileLocationRequest {
command: CommandTypes.Indentation;
arguments: IndentationRequestArgs;
}
/**
* Response for IndentationRequest request.
*/
export interface IndentationResponse extends Response {
body?: IndentationResult;
}
/**
* Indentation result representing where indentation should be placed
*/
export interface IndentationResult {
/**
* The base position in the document that the indent should be relative to
*/
position: number;
/**
* The number of columns the indent should be at relative to the position's column.
*/
indentation: number;
}
/**
* Arguments for IndentationRequest request.
*/
export interface IndentationRequestArgs extends FileLocationRequestArgs {
/**
* An optional set of settings to be used when computing indentation.
* If argument is omitted - then it will use settings for file that were previously set via 'configure' request or global settings.
*/
options?: EditorSettings;
}
/**
* Arguments for ProjectInfoRequest request.
*/
export interface ProjectInfoRequestArgs extends FileRequestArgs {
/**
* Indicate if the file name list of the project is needed
*/
needFileNameList: boolean;
/**
* if true returns details about default configured project calculation
*/
needDefaultConfiguredProjectInfo?: boolean;
}
/**
* A request to get the project information of the current file.
*/
export interface ProjectInfoRequest extends Request {
command: CommandTypes.ProjectInfo;
arguments: ProjectInfoRequestArgs;
}
/**
* A request to retrieve compiler options diagnostics for a project
*/
export interface CompilerOptionsDiagnosticsRequest extends Request {
arguments: CompilerOptionsDiagnosticsRequestArgs;
}
/**
* Arguments for CompilerOptionsDiagnosticsRequest request.
*/
export interface CompilerOptionsDiagnosticsRequestArgs {
/**
* Name of the project to retrieve compiler options diagnostics.
*/
projectFileName: string;
}
/**
* Details about the default project for the file if tsconfig file is found
*/
export interface DefaultConfiguredProjectInfo {
/** List of config files looked and did not match because file was not part of root file names */
notMatchedByConfig?: readonly string[];
/** List of projects which were loaded but file was not part of the project or is file from referenced project */
notInProject?: readonly string[];
/** Configured project used as default */
defaultProject?: string;
}
/**
* Response message body for "projectInfo" request
*/
export interface ProjectInfo {
/**
* For configured project, this is the normalized path of the 'tsconfig.json' file
* For inferred project, this is undefined
*/
configFileName: string;
/**
* The list of normalized file name in the project, including 'lib.d.ts'
*/
fileNames?: string[];
/**
* Indicates if the project has a active language service instance
*/
languageServiceDisabled?: boolean;
/**
* Information about default project
*/
configuredProjectInfo?: DefaultConfiguredProjectInfo;
}
/**
* Represents diagnostic info that includes location of diagnostic in two forms
* - start position and length of the error span
* - startLocation and endLocation - a pair of Location objects that store start/end line and offset of the error span.
*/
export interface DiagnosticWithLinePosition {
message: string;
start: number;
length: number;
startLocation: Location;
endLocation: Location;
category: string;
code: number;
/** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
reportsUnnecessary?: {};
reportsDeprecated?: {};
relatedInformation?: DiagnosticRelatedInformation[];
}
/**
* Response message for "projectInfo" request
*/
export interface ProjectInfoResponse extends Response {
body?: ProjectInfo;
}
/**
* Request whose sole parameter is a file name.
*/
export interface FileRequest extends Request {
arguments: FileRequestArgs;
}
/**
* Instances of this interface specify a location in a source file:
* (file, line, character offset), where line and character offset are 1-based.
*/
export interface FileLocationRequestArgs extends FileRequestArgs {
/**
* The line number for the request (1-based).
*/
line: number;
/**
* The character offset (on the line) for the request (1-based).
*/
offset: number;
}
export type FileLocationOrRangeRequestArgs = FileLocationRequestArgs | FileRangeRequestArgs;
/**
* Request refactorings at a given position or selection area.
*/
export interface GetApplicableRefactorsRequest extends Request {
command: CommandTypes.GetApplicableRefactors;
arguments: GetApplicableRefactorsRequestArgs;
}
export type GetApplicableRefactorsRequestArgs = FileLocationOrRangeRequestArgs & {
triggerReason?: RefactorTriggerReason;
kind?: string;
/**
* Include refactor actions that require additional arguments to be passed when
* calling 'GetEditsForRefactor'. When true, clients should inspect the
* `isInteractive` property of each returned `RefactorActionInfo`
* and ensure they are able to collect the appropriate arguments for any
* interactive refactor before offering it.
*/
includeInteractiveActions?: boolean;
};
/**
* Response is a list of available refactorings.
* Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring
*/
export interface GetApplicableRefactorsResponse extends Response {
body?: ApplicableRefactorInfo[];
}
/**
* Request refactorings at a given position or selection area to move to an existing file.
*/
export interface GetMoveToRefactoringFileSuggestionsRequest extends Request {
command: CommandTypes.GetMoveToRefactoringFileSuggestions;
arguments: GetMoveToRefactoringFileSuggestionsRequestArgs;
}
export type GetMoveToRefactoringFileSuggestionsRequestArgs = FileLocationOrRangeRequestArgs & {
kind?: string;
};
/**
* Response is a list of available files.
* Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring
*/
export interface GetMoveToRefactoringFileSuggestions extends Response {
body: {
newFileName: string;
files: string[];
};
}
/**
* Request to check if `pasteEdits` should be provided for a given location post copying text from that location.
*/
export interface PreparePasteEditsRequest extends FileRequest {
command: CommandTypes.PreparePasteEdits;
arguments: PreparePasteEditsRequestArgs;
}
export interface PreparePasteEditsRequestArgs extends FileRequestArgs {
copiedTextSpan: TextSpan[];
}
export interface PreparePasteEditsResponse extends Response {
body: boolean;
}
/**
* Request refactorings at a given position post pasting text from some other location.
*/
export interface GetPasteEditsRequest extends Request {
command: CommandTypes.GetPasteEdits;
arguments: GetPasteEditsRequestArgs;
}
export interface GetPasteEditsRequestArgs extends FileRequestArgs {
/** The text that gets pasted in a file. */
pastedText: string[];
/** Locations of where the `pastedText` gets added in a file. If the length of the `pastedText` and `pastedLocations` are not the same,
* then the `pastedText` is combined into one and added at all the `pastedLocations`.
*/
pasteLocations: TextSpan[];
/** The source location of each `pastedText`. If present, the length of `spans` must be equal to the length of `pastedText`. */
copiedFrom?: {
file: string;
spans: TextSpan[];
};
}
export interface GetPasteEditsResponse extends Response {
body: PasteEditsAction;
}
export interface PasteEditsAction {
edits: FileCodeEdits[];
fixId?: {};
}
export interface GetEditsForRefactorRequest extends Request {
command: CommandTypes.GetEditsForRefactor;
arguments: GetEditsForRefactorRequestArgs;
}
/**
* Request the edits that a particular refactoring action produces.
* Callers must specify the name of the refactor and the name of the action.
*/
export type GetEditsForRefactorRequestArgs = FileLocationOrRangeRequestArgs & {
refactor: string;
action: string;
interactiveRefactorArguments?: InteractiveRefactorArguments;
};
export interface GetEditsForRefactorResponse extends Response {
body?: RefactorEditInfo;
}
export interface RefactorEditInfo {
edits: FileCodeEdits[];
/**
* An optional location where the editor should start a rename operation once
* the refactoring edits have been applied
*/
renameLocation?: Location;
renameFilename?: string;
notApplicableReason?: string;
}
/**
* Organize imports by:
* 1) Removing unused imports
* 2) Coalescing imports from the same module
* 3) Sorting imports
*/
export interface OrganizeImportsRequest extends Request {
command: CommandTypes.OrganizeImports;
arguments: OrganizeImportsRequestArgs;
}
export type OrganizeImportsScope = GetCombinedCodeFixScope;
export interface OrganizeImportsRequestArgs {
scope: OrganizeImportsScope;
/** @deprecated Use `mode` instead */
skipDestructiveCodeActions?: boolean;
mode?: OrganizeImportsMode;
}
export interface OrganizeImportsResponse extends Response {
body: readonly FileCodeEdits[];
}
export interface GetEditsForFileRenameRequest extends Request {
command: CommandTypes.GetEditsForFileRename;
arguments: GetEditsForFileRenameRequestArgs;
}
/** Note: Paths may also be directories. */
export interface GetEditsForFileRenameRequestArgs {
readonly oldFilePath: string;
readonly newFilePath: string;
}
export interface GetEditsForFileRenameResponse extends Response {
body: readonly FileCodeEdits[];
}
/**
* Request for the available codefixes at a specific position.
*/
export interface CodeFixRequest extends Request {
command: CommandTypes.GetCodeFixes;
arguments: CodeFixRequestArgs;
}
export interface GetCombinedCodeFixRequest extends Request {
command: CommandTypes.GetCombinedCodeFix;
arguments: GetCombinedCodeFixRequestArgs;
}
export interface GetCombinedCodeFixResponse extends Response {
body: CombinedCodeActions;
}
export interface ApplyCodeActionCommandRequest extends Request {
command: CommandTypes.ApplyCodeActionCommand;
arguments: ApplyCodeActionCommandRequestArgs;
}
export interface ApplyCodeActionCommandResponse extends Response {
}
export interface FileRangeRequestArgs extends FileRequestArgs, FileRange {
}
/**
* Instances of this interface specify errorcodes on a specific location in a sourcefile.
*/
export interface CodeFixRequestArgs extends FileRangeRequestArgs {
/**
* Errorcodes we want to get the fixes for.
*/
errorCodes: readonly number[];
}
export interface GetCombinedCodeFixRequestArgs {
scope: GetCombinedCodeFixScope;
fixId: {};
}
export interface GetCombinedCodeFixScope {
type: "file";
args: FileRequestArgs;
}
export interface ApplyCodeActionCommandRequestArgs {
/** May also be an array of commands. */
command: {};
}
/**
* Response for GetCodeFixes request.
*/
export interface GetCodeFixesResponse extends Response {
body?: CodeAction[];
}
/**
* A request whose arguments specify a file location (file, line, col).
*/
export interface FileLocationRequest extends FileRequest {
arguments: FileLocationRequestArgs;
}
/**
* A request to get codes of supported code fixes.
*/
export interface GetSupportedCodeFixesRequest extends Request {
command: CommandTypes.GetSupportedCodeFixes;
arguments?: Partial;
}
/**
* A response for GetSupportedCodeFixesRequest request.
*/
export interface GetSupportedCodeFixesResponse extends Response {
/**
* List of error codes supported by the server.
*/
body?: string[];
}
/**
* A request to get encoded semantic classifications for a span in the file
*/
export interface EncodedSemanticClassificationsRequest extends FileRequest {
arguments: EncodedSemanticClassificationsRequestArgs;
}
/**
* Arguments for EncodedSemanticClassificationsRequest request.
*/
export interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs {
/**
* Start position of the span.
*/
start: number;
/**
* Length of the span.
*/
length: number;
/**
* Optional parameter for the semantic highlighting response, if absent it
* defaults to "original".
*/
format?: "original" | "2020";
}
/** The response for a EncodedSemanticClassificationsRequest */
export interface EncodedSemanticClassificationsResponse extends Response {
body?: EncodedSemanticClassificationsResponseBody;
}
/**
* Implementation response message. Gives series of text spans depending on the format ar.
*/
export interface EncodedSemanticClassificationsResponseBody {
endOfLineState: EndOfLineState;
spans: number[];
}
/**
* Arguments in document highlight request; include: filesToSearch, file,
* line, offset.
*/
export interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs {
/**
* List of files to search for document highlights.
*/
filesToSearch: string[];
}
/**
* Go to definition request; value of command field is
* "definition". Return response giving the file locations that
* define the symbol found in file at location line, col.
*/
export interface DefinitionRequest extends FileLocationRequest {
command: CommandTypes.Definition;
}
export interface DefinitionAndBoundSpanRequest extends FileLocationRequest {
readonly command: CommandTypes.DefinitionAndBoundSpan;
}
export interface FindSourceDefinitionRequest extends FileLocationRequest {
readonly command: CommandTypes.FindSourceDefinition;
}
export interface DefinitionAndBoundSpanResponse extends Response {
readonly body: DefinitionInfoAndBoundSpan;
}
/**
* Go to type request; value of command field is
* "typeDefinition". Return response giving the file locations that
* define the type for the symbol found in file at location line, col.
*/
export interface TypeDefinitionRequest extends FileLocationRequest {
command: CommandTypes.TypeDefinition;
}
/**
* Go to implementation request; value of command field is
* "implementation". Return response giving the file locations that
* implement the symbol found in file at location line, col.
*/
export interface ImplementationRequest extends FileLocationRequest {
command: CommandTypes.Implementation;
}
/**
* Location in source code expressed as (one-based) line and (one-based) column offset.
*/
export interface Location {
line: number;
offset: number;
}
/**
* Object found in response messages defining a span of text in source code.
*/
export interface TextSpan {
/**
* First character of the definition.
*/
start: Location;
/**
* One character past last character of the definition.
*/
end: Location;
}
/**
* Object found in response messages defining a span of text in a specific source file.
*/
export interface FileSpan extends TextSpan {
/**
* File containing text span.
*/
file: string;
}
export interface JSDocTagInfo {
/** Name of the JSDoc tag */
name: string;
/**
* Comment text after the JSDoc tag -- the text after the tag name until the next tag or end of comment
* Display parts when UserPreferences.displayPartsForJSDoc is true, flattened to string otherwise.
*/
text?: string | SymbolDisplayPart[];
}
export interface TextSpanWithContext extends TextSpan {
contextStart?: Location;
contextEnd?: Location;
}
export interface FileSpanWithContext extends FileSpan, TextSpanWithContext {
}
export interface DefinitionInfo extends FileSpanWithContext {
/**
* When true, the file may or may not exist.
*/
unverified?: boolean;
}
export interface DefinitionInfoAndBoundSpan {
definitions: readonly DefinitionInfo[];
textSpan: TextSpan;
}
/**
* Definition response message. Gives text range for definition.
*/
export interface DefinitionResponse extends Response {
body?: DefinitionInfo[];
}
export interface DefinitionInfoAndBoundSpanResponse extends Response {
body?: DefinitionInfoAndBoundSpan;
}
/** @deprecated Use `DefinitionInfoAndBoundSpanResponse` instead. */
export type DefinitionInfoAndBoundSpanReponse = DefinitionInfoAndBoundSpanResponse;
/**
* Definition response message. Gives text range for definition.
*/
export interface TypeDefinitionResponse extends Response {
body?: FileSpanWithContext[];
}
/**
* Implementation response message. Gives text range for implementations.
*/
export interface ImplementationResponse extends Response {
body?: FileSpanWithContext[];
}
/**
* Request to get brace completion for a location in the file.
*/
export interface BraceCompletionRequest extends FileLocationRequest {
command: CommandTypes.BraceCompletion;
arguments: BraceCompletionRequestArgs;
}
/**
* Argument for BraceCompletionRequest request.
*/
export interface BraceCompletionRequestArgs extends FileLocationRequestArgs {
/**
* Kind of opening brace
*/
openingBrace: string;
}
export interface JsxClosingTagRequest extends FileLocationRequest {
readonly command: CommandTypes.JsxClosingTag;
readonly arguments: JsxClosingTagRequestArgs;
}
export interface JsxClosingTagRequestArgs extends FileLocationRequestArgs {
}
export interface JsxClosingTagResponse extends Response {
readonly body: TextInsertion;
}
export interface LinkedEditingRangeRequest extends FileLocationRequest {
readonly command: CommandTypes.LinkedEditingRange;
}
export interface LinkedEditingRangesBody {
ranges: TextSpan[];
wordPattern?: string;
}
export interface LinkedEditingRangeResponse extends Response {
readonly body: LinkedEditingRangesBody;
}
/**
* Get document highlights request; value of command field is
* "documentHighlights". Return response giving spans that are relevant
* in the file at a given line and column.
*/
export interface DocumentHighlightsRequest extends FileLocationRequest {
command: CommandTypes.DocumentHighlights;
arguments: DocumentHighlightsRequestArgs;
}
/**
* Span augmented with extra information that denotes the kind of the highlighting to be used for span.
*/
export interface HighlightSpan extends TextSpanWithContext {
kind: HighlightSpanKind;
}
/**
* Represents a set of highligh spans for a give name
*/
export interface DocumentHighlightsItem {
/**
* File containing highlight spans.
*/
file: string;
/**
* Spans to highlight in file.
*/
highlightSpans: HighlightSpan[];
}
/**
* Response for a DocumentHighlightsRequest request.
*/
export interface DocumentHighlightsResponse extends Response {
body?: DocumentHighlightsItem[];
}
/**
* Find references request; value of command field is
* "references". Return response giving the file locations that
* reference the symbol found in file at location line, col.
*/
export interface ReferencesRequest extends FileLocationRequest {
command: CommandTypes.References;
}
export interface ReferencesResponseItem extends FileSpanWithContext {
/**
* Text of line containing the reference. Including this
* with the response avoids latency of editor loading files
* to show text of reference line (the server already has loaded the referencing files).
*
* If {@link UserPreferences.disableLineTextInReferences} is enabled, the property won't be filled
*/
lineText?: string;
/**
* True if reference is a write location, false otherwise.
*/
isWriteAccess: boolean;
/**
* Present only if the search was triggered from a declaration.
* True indicates that the references refers to the same symbol
* (i.e. has the same meaning) as the declaration that began the
* search.
*/
isDefinition?: boolean;
}
/**
* The body of a "references" response message.
*/
export interface ReferencesResponseBody {
/**
* The file locations referencing the symbol.
*/
refs: readonly ReferencesResponseItem[];
/**
* The name of the symbol.
*/
symbolName: string;
/**
* The start character offset of the symbol (on the line provided by the references request).
*/
symbolStartOffset: number;
/**
* The full display name of the symbol.
*/
symbolDisplayString: string;
}
/**
* Response to "references" request.
*/
export interface ReferencesResponse extends Response {
body?: ReferencesResponseBody;
}
export interface FileReferencesRequest extends FileRequest {
command: CommandTypes.FileReferences;
}
export interface FileReferencesResponseBody {
/**
* The file locations referencing the symbol.
*/
refs: readonly ReferencesResponseItem[];
/**
* The name of the symbol.
*/
symbolName: string;
}
export interface FileReferencesResponse extends Response {
body?: FileReferencesResponseBody;
}
/**
* Argument for RenameRequest request.
*/
export interface RenameRequestArgs extends FileLocationRequestArgs {
/**
* Should text at specified location be found/changed in comments?
*/
findInComments?: boolean;
/**
* Should text at specified location be found/changed in strings?
*/
findInStrings?: boolean;
}
/**
* Rename request; value of command field is "rename". Return
* response giving the file locations that reference the symbol
* found in file at location line, col. Also return full display
* name of the symbol so that client can print it unambiguously.
*/
export interface RenameRequest extends FileLocationRequest {
command: CommandTypes.Rename;
arguments: RenameRequestArgs;
}
/**
* Information about the item to be renamed.
*/
export type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
export type RenameInfoSuccess = ChangePropertyTypes;
/**
* A group of text spans, all in 'file'.
*/
export interface SpanGroup {
/** The file to which the spans apply */
file: string;
/** The text spans in this group */
locs: RenameTextSpan[];
}
export interface RenameTextSpan extends TextSpanWithContext {
readonly prefixText?: string;
readonly suffixText?: string;
}
export interface RenameResponseBody {
/**
* Information about the item to be renamed.
*/
info: RenameInfo;
/**
* An array of span groups (one per file) that refer to the item to be renamed.
*/
locs: readonly SpanGroup[];
}
/**
* Rename response message.
*/
export interface RenameResponse extends Response {
body?: RenameResponseBody;
}
/**
* Represents a file in external project.
* External project is project whose set of files, compilation options and open\close state
* is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio).
* External project will exist even if all files in it are closed and should be closed explicitly.
* If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will
* create configured project for every config file but will maintain a link that these projects were created
* as a result of opening external project so they should be removed once external project is closed.
*/
export interface ExternalFile {
/**
* Name of file file
*/
fileName: string;
/**
* Script kind of the file
*/
scriptKind?: ScriptKindName | ScriptKind;
/**
* Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript)
*/
hasMixedContent?: boolean;
/**
* Content of the file
*/
content?: string;
}
/**
* Represent an external project
*/
export interface ExternalProject {
/**
* Project name
*/
projectFileName: string;
/**
* List of root files in project
*/
rootFiles: ExternalFile[];
/**
* Compiler options for the project
*/
options: ExternalProjectCompilerOptions;
/**
* Explicitly specified type acquisition for the project
*/
typeAcquisition?: TypeAcquisition;
}
export interface CompileOnSaveMixin {
/**
* If compile on save is enabled for the project
*/
compileOnSave?: boolean;
}
/**
* For external projects, some of the project settings are sent together with
* compiler settings.
*/
export type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin & WatchOptions;
export interface FileWithProjectReferenceRedirectInfo {
/**
* Name of file
*/
fileName: string;
/**
* True if the file is primarily included in a referenced project
*/
isSourceOfProjectReferenceRedirect: boolean;
}
/**
* Represents a set of changes that happen in project
*/
export interface ProjectChanges {
/**
* List of added files
*/
added: string[] | FileWithProjectReferenceRedirectInfo[];
/**
* List of removed files
*/
removed: string[] | FileWithProjectReferenceRedirectInfo[];
/**
* List of updated files
*/
updated: string[] | FileWithProjectReferenceRedirectInfo[];
/**
* List of files that have had their project reference redirect status updated
* Only provided when the synchronizeProjectList request has includeProjectReferenceRedirectInfo set to true
*/
updatedRedirects?: FileWithProjectReferenceRedirectInfo[];
}
/**
* Information found in a configure request.
*/
export interface ConfigureRequestArguments {
/**
* Information about the host, for example 'Emacs 24.4' or
* 'Sublime Text version 3075'
*/
hostInfo?: string;
/**
* If present, tab settings apply only to this file.
*/
file?: string;
/**
* The format options to use during formatting and other code editing features.
*/
formatOptions?: FormatCodeSettings;
preferences?: UserPreferences;
/**
* The host's additional supported .js file extensions
*/
extraFileExtensions?: FileExtensionInfo[];
watchOptions?: WatchOptions;
}
export enum WatchFileKind {
FixedPollingInterval = "FixedPollingInterval",
PriorityPollingInterval = "PriorityPollingInterval",
DynamicPriorityPolling = "DynamicPriorityPolling",
FixedChunkSizePolling = "FixedChunkSizePolling",
UseFsEvents = "UseFsEvents",
UseFsEventsOnParentDirectory = "UseFsEventsOnParentDirectory",
}
export enum WatchDirectoryKind {
UseFsEvents = "UseFsEvents",
FixedPollingInterval = "FixedPollingInterval",
DynamicPriorityPolling = "DynamicPriorityPolling",
FixedChunkSizePolling = "FixedChunkSizePolling",
}
export enum PollingWatchKind {
FixedInterval = "FixedInterval",
PriorityInterval = "PriorityInterval",
DynamicPriority = "DynamicPriority",
FixedChunkSize = "FixedChunkSize",
}
export interface WatchOptions {
watchFile?: WatchFileKind | ts.WatchFileKind;
watchDirectory?: WatchDirectoryKind | ts.WatchDirectoryKind;
fallbackPolling?: PollingWatchKind | ts.PollingWatchKind;
synchronousWatchDirectory?: boolean;
excludeDirectories?: string[];
excludeFiles?: string[];
[option: string]: CompilerOptionsValue | undefined;
}
/**
* Configure request; value of command field is "configure". Specifies
* host information, such as host type, tab size, and indent size.
*/
export interface ConfigureRequest extends Request {
command: CommandTypes.Configure;
arguments: ConfigureRequestArguments;
}
/**
* Response to "configure" request. This is just an acknowledgement, so
* no body field is required.
*/
export interface ConfigureResponse extends Response {
}
export interface ConfigurePluginRequestArguments {
pluginName: string;
configuration: any;
}
export interface ConfigurePluginRequest extends Request {
command: CommandTypes.ConfigurePlugin;
arguments: ConfigurePluginRequestArguments;
}
export interface ConfigurePluginResponse extends Response {
}
export interface SelectionRangeRequest extends FileRequest {
command: CommandTypes.SelectionRange;
arguments: SelectionRangeRequestArgs;
}
export interface SelectionRangeRequestArgs extends FileRequestArgs {
locations: Location[];
}
export interface SelectionRangeResponse extends Response {
body?: SelectionRange[];
}
export interface SelectionRange {
textSpan: TextSpan;
parent?: SelectionRange;
}
export interface ToggleLineCommentRequest extends FileRequest {
command: CommandTypes.ToggleLineComment;
arguments: FileRangeRequestArgs;
}
export interface ToggleMultilineCommentRequest extends FileRequest {
command: CommandTypes.ToggleMultilineComment;
arguments: FileRangeRequestArgs;
}
export interface CommentSelectionRequest extends FileRequest {
command: CommandTypes.CommentSelection;
arguments: FileRangeRequestArgs;
}
export interface UncommentSelectionRequest extends FileRequest {
command: CommandTypes.UncommentSelection;
arguments: FileRangeRequestArgs;
}
/**
* Information found in an "open" request.
*/
export interface OpenRequestArgs extends FileRequestArgs {
/**
* Used when a version of the file content is known to be more up to date than the one on disk.
* Then the known content will be used upon opening instead of the disk copy
*/
fileContent?: string;
/**
* Used to specify the script kind of the file explicitly. It could be one of the following:
* "TS", "JS", "TSX", "JSX"
*/
scriptKindName?: ScriptKindName;
/**
* Used to limit the searching for project config file. If given the searching will stop at this
* root path; otherwise it will go all the way up to the dist root path.
*/
projectRootPath?: string;
}
export type ScriptKindName = "TS" | "JS" | "TSX" | "JSX";
/**
* Open request; value of command field is "open". Notify the
* server that the client has file open. The server will not
* monitor the filesystem for changes in this file and will assume
* that the client is updating the server (using the change and/or
* reload messages) when the file changes. Server does not currently
* send a response to an open request.
*/
export interface OpenRequest extends Request {
command: CommandTypes.Open;
arguments: OpenRequestArgs;
}
/**
* Request to open or update external project
*/
export interface OpenExternalProjectRequest extends Request {
command: CommandTypes.OpenExternalProject;
arguments: OpenExternalProjectArgs;
}
/**
* Arguments to OpenExternalProjectRequest request
*/
export type OpenExternalProjectArgs = ExternalProject;
/**
* Request to open multiple external projects
*/
export interface OpenExternalProjectsRequest extends Request {
command: CommandTypes.OpenExternalProjects;
arguments: OpenExternalProjectsArgs;
}
/**
* Arguments to OpenExternalProjectsRequest
*/
export interface OpenExternalProjectsArgs {
/**
* List of external projects to open or update
*/
projects: ExternalProject[];
}
/**
* Response to OpenExternalProjectRequest request. This is just an acknowledgement, so
* no body field is required.
*/
export interface OpenExternalProjectResponse extends Response {
}
/**
* Response to OpenExternalProjectsRequest request. This is just an acknowledgement, so
* no body field is required.
*/
export interface OpenExternalProjectsResponse extends Response {
}
/**
* Request to close external project.
*/
export interface CloseExternalProjectRequest extends Request {
command: CommandTypes.CloseExternalProject;
arguments: CloseExternalProjectRequestArgs;
}
/**
* Arguments to CloseExternalProjectRequest request
*/
export interface CloseExternalProjectRequestArgs {
/**
* Name of the project to close
*/
projectFileName: string;
}
/**
* Response to CloseExternalProjectRequest request. This is just an acknowledgement, so
* no body field is required.
*/
export interface CloseExternalProjectResponse extends Response {
}
/**
* Request to synchronize list of open files with the client
*/
export interface UpdateOpenRequest extends Request {
command: CommandTypes.UpdateOpen;
arguments: UpdateOpenRequestArgs;
}
/**
* Arguments to UpdateOpenRequest
*/
export interface UpdateOpenRequestArgs {
/**
* List of newly open files
*/
openFiles?: OpenRequestArgs[];
/**
* List of open files files that were changes
*/
changedFiles?: FileCodeEdits[];
/**
* List of files that were closed
*/
closedFiles?: string[];
}
/**
* External projects have a typeAcquisition option so they need to be added separately to compiler options for inferred projects.
*/
export type InferredProjectCompilerOptions = ExternalProjectCompilerOptions & TypeAcquisition;
/**
* Request to set compiler options for inferred projects.
* External projects are opened / closed explicitly.
* Configured projects are opened when user opens loose file that has 'tsconfig.json' or 'jsconfig.json' anywhere in one of containing folders.
* This configuration file will be used to obtain a list of files and configuration settings for the project.
* Inferred projects are created when user opens a loose file that is not the part of external project
* or configured project and will contain only open file and transitive closure of referenced files if 'useOneInferredProject' is false,
* or all open loose files and its transitive closure of referenced files if 'useOneInferredProject' is true.
*/
export interface SetCompilerOptionsForInferredProjectsRequest extends Request {
command: CommandTypes.CompilerOptionsForInferredProjects;
arguments: SetCompilerOptionsForInferredProjectsArgs;
}
/**
* Argument for SetCompilerOptionsForInferredProjectsRequest request.
*/
export interface SetCompilerOptionsForInferredProjectsArgs {
/**
* Compiler options to be used with inferred projects.
*/
options: InferredProjectCompilerOptions;
/**
* Specifies the project root path used to scope compiler options.
* It is an error to provide this property if the server has not been started with
* `useInferredProjectPerProjectRoot` enabled.
*/
projectRootPath?: string;
}
/**
* Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so
* no body field is required.
*/
export interface SetCompilerOptionsForInferredProjectsResponse extends Response {
}
/**
* Exit request; value of command field is "exit". Ask the server process
* to exit.
*/
export interface ExitRequest extends Request {
command: CommandTypes.Exit;
}
/**
* Close request; value of command field is "close". Notify the
* server that the client has closed a previously open file. If
* file is still referenced by open files, the server will resume
* monitoring the filesystem for changes to file. Server does not
* currently send a response to a close request.
*/
export interface CloseRequest extends FileRequest {
command: CommandTypes.Close;
}
export interface WatchChangeRequest extends Request {
command: CommandTypes.WatchChange;
arguments: WatchChangeRequestArgs | readonly WatchChangeRequestArgs[];
}
export interface WatchChangeRequestArgs {
id: number;
created?: string[];
deleted?: string[];
updated?: string[];
}
/**
* Request to obtain the list of files that should be regenerated if target file is recompiled.
* NOTE: this us query-only operation and does not generate any output on disk.
*/
export interface CompileOnSaveAffectedFileListRequest extends FileRequest {
command: CommandTypes.CompileOnSaveAffectedFileList;
}
/**
* Contains a list of files that should be regenerated in a project
*/
export interface CompileOnSaveAffectedFileListSingleProject {
/**
* Project name
*/
projectFileName: string;
/**
* List of files names that should be recompiled
*/
fileNames: string[];
/**
* true if project uses outFile or out compiler option
*/
projectUsesOutFile: boolean;
}
/**
* Response for CompileOnSaveAffectedFileListRequest request;
*/
export interface CompileOnSaveAffectedFileListResponse extends Response {
body: CompileOnSaveAffectedFileListSingleProject[];
}
/**
* Request to recompile the file. All generated outputs (.js, .d.ts or .js.map files) is written on disk.
*/
export interface CompileOnSaveEmitFileRequest extends FileRequest {
command: CommandTypes.CompileOnSaveEmitFile;
arguments: CompileOnSaveEmitFileRequestArgs;
}
/**
* Arguments for CompileOnSaveEmitFileRequest
*/
export interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs {
/**
* if true - then file should be recompiled even if it does not have any changes.
*/
forced?: boolean;
includeLinePosition?: boolean;
/** if true - return response as object with emitSkipped and diagnostics */
richResponse?: boolean;
}
export interface CompileOnSaveEmitFileResponse extends Response {
body: boolean | EmitResult;
}
export interface EmitResult {
emitSkipped: boolean;
diagnostics: Diagnostic[] | DiagnosticWithLinePosition[];
}
/**
* Quickinfo request; value of command field is
* "quickinfo". Return response giving a quick type and
* documentation string for the symbol found in file at location
* line, col.
*/
export interface QuickInfoRequest extends FileLocationRequest {
command: CommandTypes.Quickinfo;
arguments: FileLocationRequestArgs;
}
export interface QuickInfoRequestArgs extends FileLocationRequestArgs {
/**
* This controls how many levels of definitions will be expanded in the quick info response.
* The default value is 0.
*/
verbosityLevel?: number;
}
/**
* Body of QuickInfoResponse.
*/
export interface QuickInfoResponseBody {
/**
* The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
*/
kind: ScriptElementKind;
/**
* Optional modifiers for the kind (such as 'public').
*/
kindModifiers: string;
/**
* Starting file location of symbol.
*/
start: Location;
/**
* One past last character of symbol.
*/
end: Location;
/**
* Type and kind of symbol.
*/
displayString: string;
/**
* Documentation associated with symbol.
* Display parts when UserPreferences.displayPartsForJSDoc is true, flattened to string otherwise.
*/
documentation: string | SymbolDisplayPart[];
/**
* JSDoc tags associated with symbol.
*/
tags: JSDocTagInfo[];
/**
* Whether the verbosity level can be increased for this quick info response.
*/
canIncreaseVerbosityLevel?: boolean;
}
/**
* Quickinfo response message.
*/
export interface QuickInfoResponse extends Response {
body?: QuickInfoResponseBody;
}
/**
* Arguments for format messages.
*/
export interface FormatRequestArgs extends FileLocationRequestArgs {
/**
* Last line of range for which to format text in file.
*/
endLine: number;
/**
* Character offset on last line of range for which to format text in file.
*/
endOffset: number;
/**
* Format options to be used.
*/
options?: FormatCodeSettings;
}
/**
* Format request; value of command field is "format". Return
* response giving zero or more edit instructions. The edit
* instructions will be sorted in file order. Applying the edit
* instructions in reverse to file will result in correctly
* reformatted text.
*/
export interface FormatRequest extends FileLocationRequest {
command: CommandTypes.Format;
arguments: FormatRequestArgs;
}
/**
* Object found in response messages defining an editing
* instruction for a span of text in source code. The effect of
* this instruction is to replace the text starting at start and
* ending one character before end with newText. For an insertion,
* the text span is empty. For a deletion, newText is empty.
*/
export interface CodeEdit {
/**
* First character of the text span to edit.
*/
start: Location;
/**
* One character past last character of the text span to edit.
*/
end: Location;
/**
* Replace the span defined above with this string (may be
* the empty string).
*/
newText: string;
}
export interface FileCodeEdits {
fileName: string;
textChanges: CodeEdit[];
}
export interface CodeFixResponse extends Response {
/** The code actions that are available */
body?: CodeFixAction[];
}
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: FileCodeEdits[];
/** A command is an opaque object that should be passed to `ApplyCodeActionCommandRequestArgs` without modification. */
commands?: {}[];
}
export interface CombinedCodeActions {
changes: readonly FileCodeEdits[];
commands?: readonly {}[];
}
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?: {};
/** Should be present if and only if 'fixId' is. */
fixAllDescription?: string;
}
/**
* Format and format on key response message.
*/
export interface FormatResponse extends Response {
body?: CodeEdit[];
}
/**
* Arguments for format on key messages.
*/
export interface FormatOnKeyRequestArgs extends FileLocationRequestArgs {
/**
* Key pressed (';', '\n', or '}').
*/
key: string;
options?: FormatCodeSettings;
}
/**
* Format on key request; value of command field is
* "formatonkey". Given file location and key typed (as string),
* return response giving zero or more edit instructions. The
* edit instructions will be sorted in file order. Applying the
* edit instructions in reverse to file will result in correctly
* reformatted text.
*/
export interface FormatOnKeyRequest extends FileLocationRequest {
command: CommandTypes.Formatonkey;
arguments: FormatOnKeyRequestArgs;
}
/**
* Arguments for completions messages.
*/
export interface CompletionsRequestArgs extends FileLocationRequestArgs {
/**
* Optional prefix to apply to possible completions.
*/
prefix?: string;
/**
* Character that was responsible for triggering completion.
* Should be `undefined` if a user manually requested completion.
*/
triggerCharacter?: CompletionsTriggerCharacter;
triggerKind?: CompletionTriggerKind;
/**
* @deprecated Use UserPreferences.includeCompletionsForModuleExports
*/
includeExternalModuleExports?: boolean;
/**
* @deprecated Use UserPreferences.includeCompletionsWithInsertText
*/
includeInsertTextCompletions?: boolean;
}
/**
* Completions request; value of command field is "completions".
* Given a file location (file, line, col) and a prefix (which may
* be the empty string), return the possible completions that
* begin with prefix.
*/
export interface CompletionsRequest extends FileLocationRequest {
command: CommandTypes.Completions | CommandTypes.CompletionInfo;
arguments: CompletionsRequestArgs;
}
/**
* Arguments for completion details request.
*/
export interface CompletionDetailsRequestArgs extends FileLocationRequestArgs {
/**
* Names of one or more entries for which to obtain details.
*/
entryNames: (string | CompletionEntryIdentifier)[];
}
export interface CompletionEntryIdentifier {
name: string;
source?: string;
data?: unknown;
}
/**
* Completion entry details request; value of command field is
* "completionEntryDetails". Given a file location (file, line,
* col) and an array of completion entry names return more
* detailed information for each completion entry.
*/
export interface CompletionDetailsRequest extends FileLocationRequest {
command: CommandTypes.CompletionDetails;
arguments: CompletionDetailsRequestArgs;
}
/** A part of a symbol description that links from a jsdoc @link tag to a declaration */
export interface JSDocLinkDisplayPart extends SymbolDisplayPart {
/** The location of the declaration that the @link tag links to. */
target: FileSpan;
}
export type CompletionEntry = ChangePropertyTypes, {
replacementSpan: TextSpan;
data: unknown;
}>;
/**
* Additional completion entry details, available on demand
*/
export type CompletionEntryDetails = ChangePropertyTypes;
/** @deprecated Prefer CompletionInfoResponse, which supports several top-level fields in addition to the array of entries. */
export interface CompletionsResponse extends Response {
body?: CompletionEntry[];
}
export interface CompletionInfoResponse extends Response {
body?: CompletionInfo;
}
export type CompletionInfo = ChangePropertyTypes;
export interface CompletionDetailsResponse extends Response {
body?: CompletionEntryDetails[];
}
/**
* Represents a single signature to show in signature help.
*/
export type SignatureHelpItem = ChangePropertyTypes;
/**
* Signature help items found in the response of a signature help request.
*/
export interface SignatureHelpItems {
/**
* The signature help items.
*/
items: SignatureHelpItem[];
/**
* The span for which signature help should appear on a signature
*/
applicableSpan: TextSpan;
/**
* The item selected in the set of available help items.
*/
selectedItemIndex: number;
/**
* The argument selected in the set of parameters.
*/
argumentIndex: number;
/**
* The argument count
*/
argumentCount: number;
}
/**
* Arguments of a signature help request.
*/
export interface SignatureHelpRequestArgs extends FileLocationRequestArgs {
/**
* Reason why signature help was invoked.
* See each individual possible
*/
triggerReason?: SignatureHelpTriggerReason;
}
/**
* Signature help request; value of command field is "signatureHelp".
* Given a file location (file, line, col), return the signature
* help.
*/
export interface SignatureHelpRequest extends FileLocationRequest {
command: CommandTypes.SignatureHelp;
arguments: SignatureHelpRequestArgs;
}
/**
* Response object for a SignatureHelpRequest.
*/
export interface SignatureHelpResponse extends Response {
body?: SignatureHelpItems;
}
export interface InlayHintsRequestArgs extends FileRequestArgs {
/**
* Start position of the span.
*/
start: number;
/**
* Length of the span.
*/
length: number;
}
export interface InlayHintsRequest extends Request {
command: CommandTypes.ProvideInlayHints;
arguments: InlayHintsRequestArgs;
}
export type InlayHintItem = ChangePropertyTypes;
export interface InlayHintItemDisplayPart {
text: string;
span?: FileSpan;
}
export interface InlayHintsResponse extends Response {
body?: InlayHintItem[];
}
export interface MapCodeRequestArgs extends FileRequestArgs {
/**
* The files and changes to try and apply/map.
*/
mapping: MapCodeRequestDocumentMapping;
}
export interface MapCodeRequestDocumentMapping {
/**
* The specific code to map/insert/replace in the file.
*/
contents: string[];
/**
* Areas of "focus" to inform the code mapper with. For example, cursor
* location, current selection, viewport, etc. Nested arrays denote
* priority: toplevel arrays are more important than inner arrays, and
* inner array priorities are based on items within that array. Items
* earlier in the arrays have higher priority.
*/
focusLocations?: TextSpan[][];
}
export interface MapCodeRequest extends FileRequest {
command: CommandTypes.MapCode;
arguments: MapCodeRequestArgs;
}
export interface MapCodeResponse extends Response {
body: readonly FileCodeEdits[];
}
/**
* Synchronous request for semantic diagnostics of one file.
*/
export interface SemanticDiagnosticsSyncRequest extends FileRequest {
command: CommandTypes.SemanticDiagnosticsSync;
arguments: SemanticDiagnosticsSyncRequestArgs;
}
export interface SemanticDiagnosticsSyncRequestArgs extends FileRequestArgs {
includeLinePosition?: boolean;
}
/**
* Response object for synchronous sematic diagnostics request.
*/
export interface SemanticDiagnosticsSyncResponse extends Response {
body?: Diagnostic[] | DiagnosticWithLinePosition[];
}
export interface SuggestionDiagnosticsSyncRequest extends FileRequest {
command: CommandTypes.SuggestionDiagnosticsSync;
arguments: SuggestionDiagnosticsSyncRequestArgs;
}
export type SuggestionDiagnosticsSyncRequestArgs = SemanticDiagnosticsSyncRequestArgs;
export type SuggestionDiagnosticsSyncResponse = SemanticDiagnosticsSyncResponse;
/**
* Synchronous request for syntactic diagnostics of one file.
*/
export interface SyntacticDiagnosticsSyncRequest extends FileRequest {
command: CommandTypes.SyntacticDiagnosticsSync;
arguments: SyntacticDiagnosticsSyncRequestArgs;
}
export interface SyntacticDiagnosticsSyncRequestArgs extends FileRequestArgs {
includeLinePosition?: boolean;
}
/**
* Response object for synchronous syntactic diagnostics request.
*/
export interface SyntacticDiagnosticsSyncResponse extends Response {
body?: Diagnostic[] | DiagnosticWithLinePosition[];
}
/**
* Arguments for GeterrForProject request.
*/
export interface GeterrForProjectRequestArgs {
/**
* the file requesting project error list
*/
file: string;
/**
* Delay in milliseconds to wait before starting to compute
* errors for the files in the file list
*/
delay: number;
}
/**
* GeterrForProjectRequest request; value of command field is
* "geterrForProject". It works similarly with 'Geterr', only
* it request for every file in this project.
*/
export interface GeterrForProjectRequest extends Request {
command: CommandTypes.GeterrForProject;
arguments: GeterrForProjectRequestArgs;
}
/**
* Arguments for geterr messages.
*/
export interface GeterrRequestArgs {
/**
* List of file names for which to compute compiler errors.
* The files will be checked in list order.
*/
files: (string | FileRangesRequestArgs)[];
/**
* Delay in milliseconds to wait before starting to compute
* errors for the files in the file list
*/
delay: number;
}
/**
* Geterr request; value of command field is "geterr". Wait for
* delay milliseconds and then, if during the wait no change or
* reload messages have arrived for the first file in the files
* list, get the syntactic errors for the file, field requests,
* and then get the semantic errors for the file. Repeat with a
* smaller delay for each subsequent file on the files list. Best
* practice for an editor is to send a file list containing each
* file that is currently visible, in most-recently-used order.
*/
export interface GeterrRequest extends Request {
command: CommandTypes.Geterr;
arguments: GeterrRequestArgs;
}
export interface FileRange {
/**
* The line number for the request (1-based).
*/
startLine: number;
/**
* The character offset (on the line) for the request (1-based).
*/
startOffset: number;
/**
* The line number for the request (1-based).
*/
endLine: number;
/**
* The character offset (on the line) for the request (1-based).
*/
endOffset: number;
}
export interface FileRangesRequestArgs extends Pick {
ranges: FileRange[];
}
export type RequestCompletedEventName = "requestCompleted";
/**
* Event that is sent when server have finished processing request with specified id.
*/
export interface RequestCompletedEvent extends Event {
event: RequestCompletedEventName;
body: RequestCompletedEventBody;
}
export interface RequestCompletedEventBody {
request_seq: number;
performanceData?: PerformanceData;
}
/**
* Item of diagnostic information found in a DiagnosticEvent message.
*/
export interface Diagnostic {
/**
* Starting file location at which text applies.
*/
start: Location;
/**
* The last file location at which the text applies.
*/
end: Location;
/**
* Text of diagnostic message.
*/
text: string;
/**
* The category of the diagnostic message, e.g. "error", "warning", or "suggestion".
*/
category: string;
reportsUnnecessary?: {};
reportsDeprecated?: {};
/**
* Any related spans the diagnostic may have, such as other locations relevant to an error, such as declarartion sites
*/
relatedInformation?: DiagnosticRelatedInformation[];
/**
* The error code of the diagnostic message.
*/
code?: number;
/**
* The name of the plugin reporting the message.
*/
source?: string;
}
export interface DiagnosticWithFileName extends Diagnostic {
/**
* Name of the file the diagnostic is in
*/
fileName: string;
}
/**
* Represents additional spans returned with a diagnostic which are relevant to it
*/
export interface DiagnosticRelatedInformation {
/**
* The category of the related information message, e.g. "error", "warning", or "suggestion".
*/
category: string;
/**
* The code used ot identify the related information
*/
code: number;
/**
* Text of related or additional information.
*/
message: string;
/**
* Associated location
*/
span?: FileSpan;
}
export interface DiagnosticEventBody {
/**
* The file for which diagnostic information is reported.
*/
file: string;
/**
* An array of diagnostic information items.
*/
diagnostics: Diagnostic[];
/**
* Spans where the region diagnostic was requested, if this is a region semantic diagnostic event.
*/
spans?: TextSpan[];
}
export type DiagnosticEventKind = "semanticDiag" | "syntaxDiag" | "suggestionDiag" | "regionSemanticDiag";
/**
* Event message for DiagnosticEventKind event types.
* These events provide syntactic and semantic errors for a file.
*/
export interface DiagnosticEvent extends Event {
body?: DiagnosticEventBody;
event: DiagnosticEventKind;
}
export interface ConfigFileDiagnosticEventBody {
/**
* The file which trigged the searching and error-checking of the config file
*/
triggerFile: string;
/**
* The name of the found config file.
*/
configFile: string;
/**
* An arry of diagnostic information items for the found config file.
*/
diagnostics: DiagnosticWithFileName[];
}
/**
* Event message for "configFileDiag" event type.
* This event provides errors for a found config file.
*/
export interface ConfigFileDiagnosticEvent extends Event {
body?: ConfigFileDiagnosticEventBody;
event: "configFileDiag";
}
export type ProjectLanguageServiceStateEventName = "projectLanguageServiceState";
export interface ProjectLanguageServiceStateEvent extends Event {
event: ProjectLanguageServiceStateEventName;
body?: ProjectLanguageServiceStateEventBody;
}
export interface ProjectLanguageServiceStateEventBody {
/**
* Project name that has changes in the state of language service.
* For configured projects this will be the config file path.
* For external projects this will be the name of the projects specified when project was open.
* For inferred projects this event is not raised.
*/
projectName: string;
/**
* True if language service state switched from disabled to enabled
* and false otherwise.
*/
languageServiceEnabled: boolean;
}
export type ProjectsUpdatedInBackgroundEventName = "projectsUpdatedInBackground";
export interface ProjectsUpdatedInBackgroundEvent extends Event {
event: ProjectsUpdatedInBackgroundEventName;
body: ProjectsUpdatedInBackgroundEventBody;
}
export interface ProjectsUpdatedInBackgroundEventBody {
/**
* Current set of open files
*/
openFiles: string[];
}
export type ProjectLoadingStartEventName = "projectLoadingStart";
export interface ProjectLoadingStartEvent extends Event {
event: ProjectLoadingStartEventName;
body: ProjectLoadingStartEventBody;
}
export interface ProjectLoadingStartEventBody {
/** name of the project */
projectName: string;
/** reason for loading */
reason: string;
}
export type ProjectLoadingFinishEventName = "projectLoadingFinish";
export interface ProjectLoadingFinishEvent extends Event {
event: ProjectLoadingFinishEventName;
body: ProjectLoadingFinishEventBody;
}
export interface ProjectLoadingFinishEventBody {
/** name of the project */
projectName: string;
}
export type SurveyReadyEventName = "surveyReady";
export interface SurveyReadyEvent extends Event {
event: SurveyReadyEventName;
body: SurveyReadyEventBody;
}
export interface SurveyReadyEventBody {
/** Name of the survey. This is an internal machine- and programmer-friendly name */
surveyId: string;
}
export type LargeFileReferencedEventName = "largeFileReferenced";
export interface LargeFileReferencedEvent extends Event {
event: LargeFileReferencedEventName;
body: LargeFileReferencedEventBody;
}
export interface LargeFileReferencedEventBody {
/**
* name of the large file being loaded
*/
file: string;
/**
* size of the file
*/
fileSize: number;
/**
* max file size allowed on the server
*/
maxFileSize: number;
}
export type CreateFileWatcherEventName = "createFileWatcher";
export interface CreateFileWatcherEvent extends Event {
readonly event: CreateFileWatcherEventName;
readonly body: CreateFileWatcherEventBody;
}
export interface CreateFileWatcherEventBody {
readonly id: number;
readonly path: string;
}
export type CreateDirectoryWatcherEventName = "createDirectoryWatcher";
export interface CreateDirectoryWatcherEvent extends Event {
readonly event: CreateDirectoryWatcherEventName;
readonly body: CreateDirectoryWatcherEventBody;
}
export interface CreateDirectoryWatcherEventBody {
readonly id: number;
readonly path: string;
readonly recursive: boolean;
readonly ignoreUpdate?: boolean;
}
export type CloseFileWatcherEventName = "closeFileWatcher";
export interface CloseFileWatcherEvent extends Event {
readonly event: CloseFileWatcherEventName;
readonly body: CloseFileWatcherEventBody;
}
export interface CloseFileWatcherEventBody {
readonly id: number;
}
/**
* Arguments for reload request.
*/
export interface ReloadRequestArgs extends FileRequestArgs {
/**
* Name of temporary file from which to reload file
* contents. May be same as file.
*/
tmpfile: string;
}
/**
* Reload request message; value of command field is "reload".
* Reload contents of file with name given by the 'file' argument
* from temporary file with name given by the 'tmpfile' argument.
* The two names can be identical.
*/
export interface ReloadRequest extends FileRequest {
command: CommandTypes.Reload;
arguments: ReloadRequestArgs;
}
/**
* Response to "reload" request. This is just an acknowledgement, so
* no body field is required.
*/
export interface ReloadResponse extends Response {
}
/**
* Arguments for saveto request.
*/
export interface SavetoRequestArgs extends FileRequestArgs {
/**
* Name of temporary file into which to save server's view of
* file contents.
*/
tmpfile: string;
}
/**
* Saveto request message; value of command field is "saveto".
* For debugging purposes, save to a temporaryfile (named by
* argument 'tmpfile') the contents of file named by argument
* 'file'. The server does not currently send a response to a
* "saveto" request.
*/
export interface SavetoRequest extends FileRequest {
command: CommandTypes.Saveto;
arguments: SavetoRequestArgs;
}
/**
* Arguments for navto request message.
*/
export interface NavtoRequestArgs {
/**
* Search term to navigate to from current location; term can
* be '.*' or an identifier prefix.
*/
searchValue: string;
/**
* Optional limit on the number of items to return.
*/
maxResultCount?: number;
/**
* The file for the request (absolute pathname required).
*/
file?: string;
/**
* Optional flag to indicate we want results for just the current file
* or the entire project.
*/
currentFileOnly?: boolean;
projectFileName?: string;
}
/**
* Navto request message; value of command field is "navto".
* Return list of objects giving file locations and symbols that
* match the search term given in argument 'searchTerm'. The
* context for the search is given by the named file.
*/
export interface NavtoRequest extends Request {
command: CommandTypes.Navto;
arguments: NavtoRequestArgs;
}
/**
* An item found in a navto response.
*/
export interface NavtoItem extends FileSpan {
/**
* The symbol's name.
*/
name: string;
/**
* The symbol's kind (such as 'className' or 'parameterName').
*/
kind: ScriptElementKind;
/**
* exact, substring, or prefix.
*/
matchKind: string;
/**
* If this was a case sensitive or insensitive match.
*/
isCaseSensitive: boolean;
/**
* Optional modifiers for the kind (such as 'public').
*/
kindModifiers?: string;
/**
* Name of symbol's container symbol (if any); for example,
* the class name if symbol is a class member.
*/
containerName?: string;
/**
* Kind of symbol's container symbol (if any).
*/
containerKind?: ScriptElementKind;
}
/**
* Navto response message. Body is an array of navto items. Each
* item gives a symbol that matched the search term.
*/
export interface NavtoResponse extends Response {
body?: NavtoItem[];
}
/**
* Arguments for change request message.
*/
export interface ChangeRequestArgs extends FormatRequestArgs {
/**
* Optional string to insert at location (file, line, offset).
*/
insertString?: string;
}
/**
* Change request message; value of command field is "change".
* Update the server's view of the file named by argument 'file'.
* Server does not currently send a response to a change request.
*/
export interface ChangeRequest extends FileLocationRequest {
command: CommandTypes.Change;
arguments: ChangeRequestArgs;
}
/**
* Response to "brace" request.
*/
export interface BraceResponse extends Response {
body?: TextSpan[];
}
/**
* Brace matching request; value of command field is "brace".
* Return response giving the file locations of matching braces
* found in file at location line, offset.
*/
export interface BraceRequest extends FileLocationRequest {
command: CommandTypes.Brace;
}
/**
* NavBar items request; value of command field is "navbar".
* Return response giving the list of navigation bar entries
* extracted from the requested file.
*/
export interface NavBarRequest extends FileRequest {
command: CommandTypes.NavBar;
}
/**
* NavTree request; value of command field is "navtree".
* Return response giving the navigation tree of the requested file.
*/
export interface NavTreeRequest extends FileRequest {
command: CommandTypes.NavTree;
}
export interface NavigationBarItem {
/**
* The item's display text.
*/
text: string;
/**
* The symbol's kind (such as 'className' or 'parameterName').
*/
kind: ScriptElementKind;
/**
* Optional modifiers for the kind (such as 'public').
*/
kindModifiers?: string;
/**
* The definition locations of the item.
*/
spans: TextSpan[];
/**
* Optional children.
*/
childItems?: NavigationBarItem[];
/**
* Number of levels deep this item should appear.
*/
indent: number;
}
/** protocol.NavigationTree is identical to ts.NavigationTree, except using protocol.TextSpan instead of ts.TextSpan */
export interface NavigationTree {
text: string;
kind: ScriptElementKind;
kindModifiers: string;
spans: TextSpan[];
nameSpan: TextSpan | undefined;
childItems?: NavigationTree[];
}
export type TelemetryEventName = "telemetry";
export interface TelemetryEvent extends Event {
event: TelemetryEventName;
body: TelemetryEventBody;
}
export interface TelemetryEventBody {
telemetryEventName: string;
payload: any;
}
export type TypesInstallerInitializationFailedEventName = "typesInstallerInitializationFailed";
export interface TypesInstallerInitializationFailedEvent extends Event {
event: TypesInstallerInitializationFailedEventName;
body: TypesInstallerInitializationFailedEventBody;
}
export interface TypesInstallerInitializationFailedEventBody {
message: string;
}
export type TypingsInstalledTelemetryEventName = "typingsInstalled";
export interface TypingsInstalledTelemetryEventBody extends TelemetryEventBody {
telemetryEventName: TypingsInstalledTelemetryEventName;
payload: TypingsInstalledTelemetryEventPayload;
}
export interface TypingsInstalledTelemetryEventPayload {
/**
* Comma separated list of installed typing packages
*/
installedPackages: string;
/**
* true if install request succeeded, otherwise - false
*/
installSuccess: boolean;
/**
* version of typings installer
*/
typingsInstallerVersion: string;
}
export type BeginInstallTypesEventName = "beginInstallTypes";
export type EndInstallTypesEventName = "endInstallTypes";
export interface BeginInstallTypesEvent extends Event {
event: BeginInstallTypesEventName;
body: BeginInstallTypesEventBody;
}
export interface EndInstallTypesEvent extends Event {
event: EndInstallTypesEventName;
body: EndInstallTypesEventBody;
}
export interface InstallTypesEventBody {
/**
* correlation id to match begin and end events
*/
eventId: number;
/**
* list of packages to install
*/
packages: readonly string[];
}
export interface BeginInstallTypesEventBody extends InstallTypesEventBody {
}
export interface EndInstallTypesEventBody extends InstallTypesEventBody {
/**
* true if installation succeeded, otherwise false
*/
success: boolean;
}
export interface NavBarResponse extends Response {
body?: NavigationBarItem[];
}
export interface NavTreeResponse extends Response {
body?: NavigationTree;
}
export type CallHierarchyItem = ChangePropertyTypes;
export interface CallHierarchyIncomingCall {
from: CallHierarchyItem;
fromSpans: TextSpan[];
}
export interface CallHierarchyOutgoingCall {
to: CallHierarchyItem;
fromSpans: TextSpan[];
}
export interface PrepareCallHierarchyRequest extends FileLocationRequest {
command: CommandTypes.PrepareCallHierarchy;
}
export interface PrepareCallHierarchyResponse extends Response {
readonly body: CallHierarchyItem | CallHierarchyItem[];
}
export interface ProvideCallHierarchyIncomingCallsRequest extends FileLocationRequest {
command: CommandTypes.ProvideCallHierarchyIncomingCalls;
}
export interface ProvideCallHierarchyIncomingCallsResponse extends Response {
readonly body: CallHierarchyIncomingCall[];
}
export interface ProvideCallHierarchyOutgoingCallsRequest extends FileLocationRequest {
command: CommandTypes.ProvideCallHierarchyOutgoingCalls;
}
export interface ProvideCallHierarchyOutgoingCallsResponse extends Response {
readonly body: CallHierarchyOutgoingCall[];
}
export enum IndentStyle {
None = "None",
Block = "Block",
Smart = "Smart",
}
export type EditorSettings = ChangePropertyTypes;
export type FormatCodeSettings = ChangePropertyTypes;
export type CompilerOptions = ChangePropertyTypes, {
jsx: JsxEmit | ts.JsxEmit;
module: ModuleKind | ts.ModuleKind;
moduleResolution: ModuleResolutionKind | ts.ModuleResolutionKind;
newLine: NewLineKind | ts.NewLineKind;
target: ScriptTarget | ts.ScriptTarget;
}>;
export enum JsxEmit {
None = "none",
Preserve = "preserve",
ReactNative = "react-native",
React = "react",
ReactJSX = "react-jsx",
ReactJSXDev = "react-jsxdev",
}
export enum ModuleKind {
None = "none",
CommonJS = "commonjs",
AMD = "amd",
UMD = "umd",
System = "system",
ES6 = "es6",
ES2015 = "es2015",
ES2020 = "es2020",
ES2022 = "es2022",
ESNext = "esnext",
Node16 = "node16",
Node18 = "node18",
Node20 = "node20",
NodeNext = "nodenext",
Preserve = "preserve",
}
export enum ModuleResolutionKind {
Classic = "classic",
/** @deprecated Renamed to `Node10` */
Node = "node",
/** @deprecated Renamed to `Node10` */
NodeJs = "node",
Node10 = "node10",
Node16 = "node16",
NodeNext = "nodenext",
Bundler = "bundler",
}
export enum NewLineKind {
Crlf = "Crlf",
Lf = "Lf",
}
export enum ScriptTarget {
/** @deprecated */
ES3 = "es3",
ES5 = "es5",
ES6 = "es6",
ES2015 = "es2015",
ES2016 = "es2016",
ES2017 = "es2017",
ES2018 = "es2018",
ES2019 = "es2019",
ES2020 = "es2020",
ES2021 = "es2021",
ES2022 = "es2022",
ES2023 = "es2023",
ES2024 = "es2024",
ESNext = "esnext",
JSON = "json",
Latest = "esnext",
}
}
namespace typingsInstaller {
interface Log {
isEnabled(): boolean;
writeLine(text: string): void;
}
type RequestCompletedAction = (success: boolean) => void;
interface PendingRequest {
requestId: number;
packageNames: string[];
cwd: string;
onRequestCompleted: RequestCompletedAction;
}
abstract class TypingsInstaller {
protected readonly installTypingHost: InstallTypingHost;
private readonly globalCachePath;
private readonly safeListPath;
private readonly typesMapLocation;
private readonly throttleLimit;
protected readonly log: Log;
private readonly packageNameToTypingLocation;
private readonly missingTypingsSet;
private readonly knownCachesSet;
private readonly projectWatchers;
private safeList;
private pendingRunRequests;
private installRunCount;
private inFlightRequestCount;
abstract readonly typesRegistry: Map>;
constructor(installTypingHost: InstallTypingHost, globalCachePath: string, safeListPath: Path, typesMapLocation: Path, throttleLimit: number, log?: Log);
closeProject(req: CloseProject): void;
private closeWatchers;
install(req: DiscoverTypings): void;
private initializeSafeList;
private processCacheLocation;
private filterTypings;
protected ensurePackageDirectoryExists(directory: string): void;
private installTypings;
private ensureDirectoryExists;
private watchFiles;
private createSetTypings;
private installTypingsAsync;
private executeWithThrottling;
protected abstract installWorker(requestId: number, packageNames: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void;
protected abstract sendResponse(response: SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes | WatchTypingLocations): void;
protected readonly latestDistTag = "latest";
}
}
type ActionSet = "action::set";
type ActionInvalidate = "action::invalidate";
type ActionPackageInstalled = "action::packageInstalled";
type EventTypesRegistry = "event::typesRegistry";
type EventBeginInstallTypes = "event::beginInstallTypes";
type EventEndInstallTypes = "event::endInstallTypes";
type EventInitializationFailed = "event::initializationFailed";
type ActionWatchTypingLocations = "action::watchTypingLocations";
interface TypingInstallerResponse {
readonly kind: ActionSet | ActionInvalidate | EventTypesRegistry | ActionPackageInstalled | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed | ActionWatchTypingLocations;
}
interface TypingInstallerRequestWithProjectName {
readonly projectName: string;
}
interface DiscoverTypings extends TypingInstallerRequestWithProjectName {
readonly fileNames: string[];
readonly projectRootPath: Path;
readonly compilerOptions: CompilerOptions;
readonly typeAcquisition: TypeAcquisition;
readonly unresolvedImports: SortedReadonlyArray;
readonly cachePath?: string;
readonly kind: "discover";
}
interface CloseProject extends TypingInstallerRequestWithProjectName {
readonly kind: "closeProject";
}
interface TypesRegistryRequest {
readonly kind: "typesRegistry";
}
interface InstallPackageRequest extends TypingInstallerRequestWithProjectName {
readonly kind: "installPackage";
readonly fileName: Path;
readonly packageName: string;
readonly projectRootPath: Path;
readonly id: number;
}
interface PackageInstalledResponse extends ProjectResponse {
readonly kind: ActionPackageInstalled;
readonly id: number;
readonly success: boolean;
readonly message: string;
}
interface InitializationFailedResponse extends TypingInstallerResponse {
readonly kind: EventInitializationFailed;
readonly message: string;
readonly stack?: string;
}
interface ProjectResponse extends TypingInstallerResponse {
readonly projectName: string;
}
interface InvalidateCachedTypings extends ProjectResponse {
readonly kind: ActionInvalidate;
}
interface InstallTypes extends ProjectResponse {
readonly kind: EventBeginInstallTypes | EventEndInstallTypes;
readonly eventId: number;
readonly typingsInstallerVersion: string;
readonly packagesToInstall: readonly string[];
}
interface BeginInstallTypes extends InstallTypes {
readonly kind: EventBeginInstallTypes;
}
interface EndInstallTypes extends InstallTypes {
readonly kind: EventEndInstallTypes;
readonly installSuccess: boolean;
}
interface InstallTypingHost extends JsTyping.TypingResolutionHost {
useCaseSensitiveFileNames: boolean;
writeFile(path: string, content: string): void;
createDirectory(path: string): void;
getCurrentDirectory?(): string;
}
interface SetTypings extends ProjectResponse {
readonly typeAcquisition: TypeAcquisition;
readonly compilerOptions: CompilerOptions;
readonly typings: string[];
readonly unresolvedImports: SortedReadonlyArray;
readonly kind: ActionSet;
}
interface WatchTypingLocations extends ProjectResponse {
/** if files is undefined, retain same set of watchers */
readonly files: readonly string[] | undefined;
readonly kind: ActionWatchTypingLocations;
}
interface CompressedData {
length: number;
compressionKind: string;
data: any;
}
type ModuleImportResult = {
module: {};
error: undefined;
} | {
module: undefined;
error: {
stack?: string;
message?: string;
};
};
/** @deprecated Use {@link ModuleImportResult} instead. */
type RequireResult = ModuleImportResult;
interface ServerHost extends System {
watchFile(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
watchDirectory(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
preferNonRecursiveWatch?: boolean;
setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
clearTimeout(timeoutId: any): void;
setImmediate(callback: (...args: any[]) => void, ...args: any[]): any;
clearImmediate(timeoutId: any): void;
gc?(): void;
trace?(s: string): void;
require?(initialPath: string, moduleName: string): ModuleImportResult;
}
interface InstallPackageOptionsWithProject extends InstallPackageOptions {
projectName: string;
projectRootPath: Path;
}
interface ITypingsInstaller {
isKnownTypesPackageName(name: string): boolean;
installPackage(options: InstallPackageOptionsWithProject): Promise;
enqueueInstallTypingsRequest(p: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray | undefined): void;
attach(projectService: ProjectService): void;
onProjectClosed(p: Project): void;
readonly globalTypingsCacheLocation: string | undefined;
}
function createInstallTypingsRequest(project: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray, cachePath?: string): DiscoverTypings;
function toNormalizedPath(fileName: string): NormalizedPath;
function normalizedPathToPath(normalizedPath: NormalizedPath, currentDirectory: string, getCanonicalFileName: (f: string) => string): Path;
function asNormalizedPath(fileName: string): NormalizedPath;
function createNormalizedPathMap(): NormalizedPathMap;
function isInferredProjectName(name: string): boolean;
function makeInferredProjectName(counter: number): string;
function createSortedArray(): SortedArray;
enum LogLevel {
terse = 0,
normal = 1,
requestTime = 2,
verbose = 3,
}
const emptyArray: SortedReadonlyArray;
interface Logger {
close(): void;
hasLevel(level: LogLevel): boolean;
loggingEnabled(): boolean;
perftrc(s: string): void;
info(s: string): void;
startGroup(): void;
endGroup(): void;
msg(s: string, type?: Msg): void;
getLogFileName(): string | undefined;
}
enum Msg {
Err = "Err",
Info = "Info",
Perf = "Perf",
}
namespace Errors {
function ThrowNoProject(): never;
function ThrowProjectLanguageServiceDisabled(): never;
function ThrowProjectDoesNotContainDocument(fileName: string, project: Project): never;
}
type NormalizedPath = string & {
__normalizedPathTag: any;
};
interface NormalizedPathMap {
get(path: NormalizedPath): T | undefined;
set(path: NormalizedPath, value: T): void;
contains(path: NormalizedPath): boolean;
remove(path: NormalizedPath): void;
}
function isDynamicFileName(fileName: NormalizedPath): boolean;
class ScriptInfo {
private readonly host;
readonly fileName: NormalizedPath;
readonly scriptKind: ScriptKind;
readonly hasMixedContent: boolean;
readonly path: Path;
/**
* All projects that include this file
*/
readonly containingProjects: Project[];
private formatSettings;
private preferences;
private realpath;
constructor(host: ServerHost, fileName: NormalizedPath, scriptKind: ScriptKind, hasMixedContent: boolean, path: Path, initialVersion?: number);
isScriptOpen(): boolean;
open(newText: string | undefined): void;
close(fileExists?: boolean): void;
getSnapshot(): IScriptSnapshot;
private ensureRealPath;
getFormatCodeSettings(): FormatCodeSettings | undefined;
getPreferences(): protocol.UserPreferences | undefined;
attachToProject(project: Project): boolean;
isAttached(project: Project): boolean;
detachFromProject(project: Project): void;
detachAllProjects(): void;
getDefaultProject(): Project;
registerFileUpdate(): void;
setOptions(formatSettings: FormatCodeSettings, preferences: protocol.UserPreferences | undefined): void;
getLatestVersion(): string;
saveTo(fileName: string): void;
reloadFromFile(tempFileName?: NormalizedPath): boolean;
editContent(start: number, end: number, newText: string): void;
markContainingProjectsAsDirty(): void;
isOrphan(): boolean;
/**
* @param line 1 based index
*/
lineToTextSpan(line: number): TextSpan;
/**
* @param line 1 based index
* @param offset 1 based index
*/
lineOffsetToPosition(line: number, offset: number): number;
positionToLineOffset(position: number): protocol.Location;
isJavaScript(): boolean;
}
function allRootFilesAreJsOrDts(project: Project): boolean;
function allFilesAreJsOrDts(project: Project): boolean;
enum ProjectKind {
Inferred = 0,
Configured = 1,
External = 2,
AutoImportProvider = 3,
Auxiliary = 4,
}
interface PluginCreateInfo {
project: Project;
languageService: LanguageService;
languageServiceHost: LanguageServiceHost;
serverHost: ServerHost;
session?: Session;
config: any;
}
interface PluginModule {
create(createInfo: PluginCreateInfo): LanguageService;
getExternalFiles?(proj: Project, updateLevel: ProgramUpdateLevel): string[];
onConfigurationChanged?(config: any): void;
}
interface PluginModuleWithName {
name: string;
module: PluginModule;
}
type PluginModuleFactory = (mod: {
typescript: typeof ts;
}) => PluginModule;
abstract class Project implements LanguageServiceHost, ModuleResolutionHost {
readonly projectKind: ProjectKind;
readonly projectService: ProjectService;
private compilerOptions;
compileOnSaveEnabled: boolean;
protected watchOptions: WatchOptions | undefined;
private rootFilesMap;
private program;
private externalFiles;
private missingFilesMap;
private generatedFilesMap;
private hasAddedorRemovedFiles;
private hasAddedOrRemovedSymlinks;
protected languageService: LanguageService;
languageServiceEnabled: boolean;
readonly trace?: (s: string) => void;
readonly realpath?: (path: string) => string;
private builderState;
private updatedFileNames;
private lastReportedFileNames;
private lastReportedVersion;
protected projectErrors: Diagnostic[] | undefined;
private typingsCache;
private typingWatchers;
private readonly cancellationToken;
isNonTsProject(): boolean;
isJsOnlyProject(): boolean;
static resolveModule(moduleName: string, initialDir: string, host: ServerHost, log: (message: string) => void): {} | undefined;
private exportMapCache;
private changedFilesForExportMapCache;
private moduleSpecifierCache;
private symlinks;
readonly jsDocParsingMode: JSDocParsingMode | undefined;
isKnownTypesPackageName(name: string): boolean;
installPackage(options: InstallPackageOptions): Promise;
getCompilationSettings(): CompilerOptions;
getCompilerOptions(): CompilerOptions;
getNewLine(): string;
getProjectVersion(): string;
getProjectReferences(): readonly ProjectReference[] | undefined;
getScriptFileNames(): string[];
private getOrCreateScriptInfoAndAttachToProject;
getScriptKind(fileName: string): ScriptKind;
getScriptVersion(filename: string): string;
getScriptSnapshot(filename: string): IScriptSnapshot | undefined;
getCancellationToken(): HostCancellationToken;
getCurrentDirectory(): string;
getDefaultLibFileName(): string;
useCaseSensitiveFileNames(): boolean;
readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
readFile(fileName: string): string | undefined;
writeFile(fileName: string, content: string): void;
fileExists(file: string): boolean;
directoryExists(path: string): boolean;
getDirectories(path: string): string[];
log(s: string): void;
error(s: string): void;
private setInternalCompilerOptionsForEmittingJsFiles;
/**
* Get the errors that dont have any file name associated
*/
getGlobalProjectErrors(): readonly Diagnostic[];
/**
* Get all the project errors
*/
getAllProjectErrors(): readonly Diagnostic[];
setProjectErrors(projectErrors: Diagnostic[] | undefined): void;
getLanguageService(ensureSynchronized?: boolean): LanguageService;
getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[];
/**
* Returns true if emit was conducted
*/
emitFile(scriptInfo: ScriptInfo, writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => void): EmitResult;
enableLanguageService(): void;
disableLanguageService(lastFileExceededProgramSize?: string): void;
getProjectName(): string;
protected removeLocalTypingsFromTypeAcquisition(newTypeAcquisition: TypeAcquisition): TypeAcquisition;
getExternalFiles(updateLevel?: ProgramUpdateLevel): SortedReadonlyArray;
getSourceFile(path: Path): SourceFile | undefined;
close(): void;
private detachScriptInfoIfNotRoot;
isClosed(): boolean;
hasRoots(): boolean;
getRootFiles(): NormalizedPath[];
getRootScriptInfos(): ScriptInfo[];
getScriptInfos(): ScriptInfo[];
getExcludedFiles(): readonly NormalizedPath[];
getFileNames(excludeFilesFromExternalLibraries?: boolean, excludeConfigFiles?: boolean): NormalizedPath[];
hasConfigFile(configFilePath: NormalizedPath): boolean;
containsScriptInfo(info: ScriptInfo): boolean;
containsFile(filename: NormalizedPath, requireOpen?: boolean): boolean;
isRoot(info: ScriptInfo): boolean;
addRoot(info: ScriptInfo, fileName?: NormalizedPath): void;
addMissingFileRoot(fileName: NormalizedPath): void;
removeFile(info: ScriptInfo, fileExists: boolean, detachFromProject: boolean): void;
registerFileUpdate(fileName: string): void;
/**
* Updates set of files that contribute to this project
* @returns: true if set of files in the project stays the same and false - otherwise.
*/
updateGraph(): boolean;
private closeWatchingTypingLocations;
private onTypingInstallerWatchInvoke;
protected removeExistingTypings(include: string[]): string[];
private updateGraphWorker;
private detachScriptInfoFromProject;
private addMissingFileWatcher;
private isWatchedMissingFile;
private createGeneratedFileWatcher;
private isValidGeneratedFileWatcher;
private clearGeneratedFileWatch;
getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo | undefined;
getScriptInfo(uncheckedFileName: string): ScriptInfo | undefined;
filesToString(writeProjectFileNames: boolean): string;
private filesToStringWorker;
setCompilerOptions(compilerOptions: CompilerOptions): void;
setTypeAcquisition(newTypeAcquisition: TypeAcquisition | undefined): void;
getTypeAcquisition(): TypeAcquisition;
protected removeRoot(info: ScriptInfo): void;
protected enableGlobalPlugins(options: CompilerOptions): void;
protected enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[]): void;
/** Starts a new check for diagnostics. Call this if some file has updated that would cause diagnostics to be changed. */
refreshDiagnostics(): void;
private isDefaultProjectForOpenFiles;
}
/**
* If a file is opened and no tsconfig (or jsconfig) is found,
* the file and its imports/references are put into an InferredProject.
*/
class InferredProject extends Project {
private _isJsInferredProject;
toggleJsInferredProject(isJsInferredProject: boolean): void;
setCompilerOptions(options?: CompilerOptions): void;
/** this is canonical project root path */
readonly projectRootPath: string | undefined;
addRoot(info: ScriptInfo): void;
removeRoot(info: ScriptInfo): void;
isProjectWithSingleRoot(): boolean;
close(): void;
getTypeAcquisition(): TypeAcquisition;
}
class AutoImportProviderProject extends Project {
private hostProject;
private static readonly maxDependencies;
private rootFileNames;
updateGraph(): boolean;
hasRoots(): boolean;
getScriptFileNames(): string[];
getLanguageService(): never;
getHostForAutoImportProvider(): never;
getProjectReferences(): readonly ProjectReference[] | undefined;
}
/**
* If a file is opened, the server will look for a tsconfig (or jsconfig)
* and if successful create a ConfiguredProject for it.
* Otherwise it will create an InferredProject.
*/
class ConfiguredProject extends Project {
readonly canonicalConfigFilePath: NormalizedPath;
private projectReferences;
private compilerHost?;
private releaseParsedConfig;
/**
* If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph
* @returns: true if set of files in the project stays the same and false - otherwise.
*/
updateGraph(): boolean;
getConfigFilePath(): NormalizedPath;
getProjectReferences(): readonly ProjectReference[] | undefined;
updateReferences(refs: readonly ProjectReference[] | undefined): void;
/**
* Get the errors that dont have any file name associated
*/
getGlobalProjectErrors(): readonly Diagnostic[];
/**
* Get all the project errors
*/
getAllProjectErrors(): readonly Diagnostic[];
setProjectErrors(projectErrors: Diagnostic[]): void;
close(): void;
getEffectiveTypeRoots(): string[];
}
/**
* Project whose configuration is handled externally, such as in a '.csproj'.
* These are created only if a host explicitly calls `openExternalProject`.
*/
class ExternalProject extends Project {
externalProjectName: string;
compileOnSaveEnabled: boolean;
excludedFiles: readonly NormalizedPath[];
updateGraph(): boolean;
getExcludedFiles(): readonly NormalizedPath[];
}
function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings;
function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin;
function convertWatchOptions(protocolOptions: protocol.ExternalProjectCompilerOptions, currentDirectory?: string): WatchOptionsAndErrors | undefined;
function convertTypeAcquisition(protocolOptions: protocol.InferredProjectCompilerOptions): TypeAcquisition | undefined;
function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind;
function convertScriptKindName(scriptKindName: protocol.ScriptKindName): ScriptKind;
const maxProgramSizeForNonTsFiles: number;
const ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground";
interface ProjectsUpdatedInBackgroundEvent {
eventName: typeof ProjectsUpdatedInBackgroundEvent;
data: {
openFiles: string[];
};
}
const ProjectLoadingStartEvent = "projectLoadingStart";
interface ProjectLoadingStartEvent {
eventName: typeof ProjectLoadingStartEvent;
data: {
project: Project;
reason: string;
};
}
const ProjectLoadingFinishEvent = "projectLoadingFinish";
interface ProjectLoadingFinishEvent {
eventName: typeof ProjectLoadingFinishEvent;
data: {
project: Project;
};
}
const LargeFileReferencedEvent = "largeFileReferenced";
interface LargeFileReferencedEvent {
eventName: typeof LargeFileReferencedEvent;
data: {
file: string;
fileSize: number;
maxFileSize: number;
};
}
const ConfigFileDiagEvent = "configFileDiag";
interface ConfigFileDiagEvent {
eventName: typeof ConfigFileDiagEvent;
data: {
triggerFile: string;
configFileName: string;
diagnostics: readonly Diagnostic[];
};
}
const ProjectLanguageServiceStateEvent = "projectLanguageServiceState";
interface ProjectLanguageServiceStateEvent {
eventName: typeof ProjectLanguageServiceStateEvent;
data: {
project: Project;
languageServiceEnabled: boolean;
};
}
const ProjectInfoTelemetryEvent = "projectInfo";
/** This will be converted to the payload of a protocol.TelemetryEvent in session.defaultEventHandler. */
interface ProjectInfoTelemetryEvent {
readonly eventName: typeof ProjectInfoTelemetryEvent;
readonly data: ProjectInfoTelemetryEventData;
}
const OpenFileInfoTelemetryEvent = "openFileInfo";
/**
* Info that we may send about a file that was just opened.
* Info about a file will only be sent once per session, even if the file changes in ways that might affect the info.
* Currently this is only sent for '.js' files.
*/
interface OpenFileInfoTelemetryEvent {
readonly eventName: typeof OpenFileInfoTelemetryEvent;
readonly data: OpenFileInfoTelemetryEventData;
}
const CreateFileWatcherEvent: protocol.CreateFileWatcherEventName;
interface CreateFileWatcherEvent {
readonly eventName: protocol.CreateFileWatcherEventName;
readonly data: protocol.CreateFileWatcherEventBody;
}
const CreateDirectoryWatcherEvent: protocol.CreateDirectoryWatcherEventName;
interface CreateDirectoryWatcherEvent {
readonly eventName: protocol.CreateDirectoryWatcherEventName;
readonly data: protocol.CreateDirectoryWatcherEventBody;
}
const CloseFileWatcherEvent: protocol.CloseFileWatcherEventName;
interface CloseFileWatcherEvent {
readonly eventName: protocol.CloseFileWatcherEventName;
readonly data: protocol.CloseFileWatcherEventBody;
}
interface ProjectInfoTelemetryEventData {
/** Cryptographically secure hash of project file location. */
readonly projectId: string;
/** Count of file extensions seen in the project. */
readonly fileStats: FileStats;
/**
* Any compiler options that might contain paths will be taken out.
* Enum compiler options will be converted to strings.
*/
readonly compilerOptions: CompilerOptions;
readonly extends: boolean | undefined;
readonly files: boolean | undefined;
readonly include: boolean | undefined;
readonly exclude: boolean | undefined;
readonly compileOnSave: boolean;
readonly typeAcquisition: ProjectInfoTypeAcquisitionData;
readonly configFileName: "tsconfig.json" | "jsconfig.json" | "other";
readonly projectType: "external" | "configured";
readonly languageServiceEnabled: boolean;
/** TypeScript version used by the server. */
readonly version: string;
}
interface OpenFileInfoTelemetryEventData {
readonly info: OpenFileInfo;
}
interface ProjectInfoTypeAcquisitionData {
readonly enable: boolean | undefined;
readonly include: boolean;
readonly exclude: boolean;
}
interface FileStats {
readonly js: number;
readonly jsSize?: number;
readonly jsx: number;
readonly jsxSize?: number;
readonly ts: number;
readonly tsSize?: number;
readonly tsx: number;
readonly tsxSize?: number;
readonly dts: number;
readonly dtsSize?: number;
readonly deferred: number;
readonly deferredSize?: number;
}
interface OpenFileInfo {
readonly checkJs: boolean;
}
type ProjectServiceEvent = LargeFileReferencedEvent | ProjectsUpdatedInBackgroundEvent | ProjectLoadingStartEvent | ProjectLoadingFinishEvent | ConfigFileDiagEvent | ProjectLanguageServiceStateEvent | ProjectInfoTelemetryEvent | OpenFileInfoTelemetryEvent | CreateFileWatcherEvent | CreateDirectoryWatcherEvent | CloseFileWatcherEvent;
type ProjectServiceEventHandler = (event: ProjectServiceEvent) => void;
interface SafeList {
[name: string]: {
match: RegExp;
exclude?: (string | number)[][];
types?: string[];
};
}
interface TypesMapFile {
typesMap: SafeList;
simpleMap: {
[libName: string]: string;
};
}
interface HostConfiguration {
formatCodeOptions: FormatCodeSettings;
preferences: protocol.UserPreferences;
hostInfo: string;
extraFileExtensions?: FileExtensionInfo[];
watchOptions?: WatchOptions;
}
interface OpenConfiguredProjectResult {
configFileName?: NormalizedPath;
configFileErrors?: readonly Diagnostic[];
}
const nullTypingsInstaller: ITypingsInstaller;
interface ProjectServiceOptions {
host: ServerHost;
logger: Logger;
cancellationToken: HostCancellationToken;
useSingleInferredProject: boolean;
useInferredProjectPerProjectRoot: boolean;
typingsInstaller?: ITypingsInstaller;
eventHandler?: ProjectServiceEventHandler;
canUseWatchEvents?: boolean;
suppressDiagnosticEvents?: boolean;
throttleWaitMilliseconds?: number;
globalPlugins?: readonly string[];
pluginProbeLocations?: readonly string[];
allowLocalPluginLoads?: boolean;
typesMapLocation?: string;
serverMode?: LanguageServiceMode;
session: Session | undefined;
jsDocParsingMode?: JSDocParsingMode;
}
interface WatchOptionsAndErrors {
watchOptions: WatchOptions;
errors: Diagnostic[] | undefined;
}
class ProjectService {
private readonly nodeModulesWatchers;
private readonly filenameToScriptInfoVersion;
private readonly allJsFilesForOpenFileTelemetry;
private readonly externalProjectToConfiguredProjectMap;
/**
* external projects (configuration and list of root files is not controlled by tsserver)
*/
readonly externalProjects: ExternalProject[];
/**
* projects built from openFileRoots
*/
readonly inferredProjects: InferredProject[];
/**
* projects specified by a tsconfig.json file
*/
readonly configuredProjects: Map;
/**
* Open files: with value being project root path, and key being Path of the file that is open
*/
readonly openFiles: Map;
private readonly configFileForOpenFiles;
private rootOfInferredProjects;
private readonly openFilesWithNonRootedDiskPath;
private compilerOptionsForInferredProjects;
private compilerOptionsForInferredProjectsPerProjectRoot;
private watchOptionsForInferredProjects;
private watchOptionsForInferredProjectsPerProjectRoot;
private typeAcquisitionForInferredProjects;
private typeAcquisitionForInferredProjectsPerProjectRoot;
private readonly projectToSizeMap;
private readonly hostConfiguration;
private safelist;
private readonly legacySafelist;
private pendingProjectUpdates;
private pendingOpenFileProjectUpdates?;
readonly currentDirectory: NormalizedPath;
readonly toCanonicalFileName: (f: string) => string;
readonly host: ServerHost;
readonly logger: Logger;
readonly cancellationToken: HostCancellationToken;
readonly useSingleInferredProject: boolean;
readonly useInferredProjectPerProjectRoot: boolean;
readonly typingsInstaller: ITypingsInstaller;
private readonly globalCacheLocationDirectoryPath;
readonly throttleWaitMilliseconds?: number;
private readonly suppressDiagnosticEvents?;
readonly globalPlugins: readonly string[];
readonly pluginProbeLocations: readonly string[];
readonly allowLocalPluginLoads: boolean;
readonly typesMapLocation: string | undefined;
readonly serverMode: LanguageServiceMode;
private readonly seenProjects;
private readonly sharedExtendedConfigFileWatchers;
private readonly extendedConfigCache;
private packageJsonFilesMap;
private incompleteCompletionsCache;
private performanceEventHandler?;
private pendingPluginEnablements?;
private currentPluginEnablementPromise?;
readonly jsDocParsingMode: JSDocParsingMode | undefined;
constructor(opts: ProjectServiceOptions);
toPath(fileName: string): Path;
private loadTypesMap;
updateTypingsForProject(response: SetTypings | InvalidateCachedTypings | PackageInstalledResponse): void;
private delayUpdateProjectGraph;
private delayUpdateProjectGraphs;
setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.InferredProjectCompilerOptions, projectRootPath?: string): void;
findProject(projectName: string): Project | undefined;
getDefaultProjectForFile(fileName: NormalizedPath, ensureProject: boolean): Project | undefined;
private tryGetDefaultProjectForEnsuringConfiguredProjectForFile;
private doEnsureDefaultProjectForFile;
getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName: string): ScriptInfo | undefined;
private ensureProjectStructuresUptoDate;
getFormatCodeOptions(file: NormalizedPath): FormatCodeSettings;
getPreferences(file: NormalizedPath): protocol.UserPreferences;
getHostFormatCodeOptions(): FormatCodeSettings;
getHostPreferences(): protocol.UserPreferences;
private onSourceFileChanged;
private handleSourceMapProjects;
private delayUpdateSourceInfoProjects;
private delayUpdateProjectsOfScriptInfoPath;
private handleDeletedFile;
private watchWildcardDirectory;
private onWildCardDirectoryWatcherInvoke;
private delayUpdateProjectsFromParsedConfigOnConfigFileChange;
private onConfigFileChanged;
private removeProject;
private assignOrphanScriptInfosToInferredProject;
private closeOpenFile;
private deleteScriptInfo;
private configFileExists;
private createConfigFileWatcherForParsedConfig;
private ensureConfigFileWatcherForProject;
private forEachConfigFileLocation;
private getConfigFileNameForFileFromCache;
private setConfigFileNameForFileInCache;
private printProjects;
private getConfiguredProjectByCanonicalConfigFilePath;
private findExternalProjectByProjectName;
private getFilenameForExceededTotalSizeLimitForNonTsFiles;
private createExternalProject;
private addFilesToNonInferredProject;
private loadConfiguredProject;
private updateNonInferredProjectFiles;
private updateRootAndOptionsOfNonInferredProject;
private reloadFileNamesOfParsedConfig;
private setProjectForReload;
private clearSemanticCache;
private getOrCreateInferredProjectForProjectRootPathIfEnabled;
private getOrCreateSingleInferredProjectIfEnabled;
private getOrCreateSingleInferredWithoutProjectRoot;
private createInferredProject;
getScriptInfo(uncheckedFileName: string): ScriptInfo | undefined;
private watchClosedScriptInfo;
private createNodeModulesWatcher;
private watchClosedScriptInfoInNodeModules;
private getModifiedTime;
private refreshScriptInfo;
private refreshScriptInfosInDirectory;
private stopWatchingScriptInfo;
private getOrCreateScriptInfoNotOpenedByClientForNormalizedPath;
getOrCreateScriptInfoForNormalizedPath(fileName: NormalizedPath, openedByClient: boolean, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, hostToQueryFileExistsOn?: {
fileExists(path: string): boolean;
}): ScriptInfo | undefined;
private getOrCreateScriptInfoWorker;
/**
* This gets the script info for the normalized path. If the path is not rooted disk path then the open script info with project root context is preferred
*/
getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo | undefined;
getScriptInfoForPath(fileName: Path): ScriptInfo | undefined;
private addSourceInfoToSourceMap;
private addMissingSourceMapFile;
setHostConfiguration(args: protocol.ConfigureRequestArguments): void;
private getWatchOptionsFromProjectWatchOptions;
closeLog(): void;
private sendSourceFileChange;
/**
* This function rebuilds the project for every file opened by the client
* This does not reload contents of open files from disk. But we could do that if needed
*/
reloadProjects(): void;
private removeRootOfInferredProjectIfNowPartOfOtherProject;
private ensureProjectForOpenFiles;
/**
* Open file whose contents is managed by the client
* @param filename is absolute pathname
* @param fileContent is a known version of the file content that is more up to date than the one on disk
*/
openClientFile(fileName: string, fileContent?: string, scriptKind?: ScriptKind, projectRootPath?: string): OpenConfiguredProjectResult;
private findExternalProjectContainingOpenScriptInfo;
private getOrCreateOpenScriptInfo;
private assignProjectToOpenedScriptInfo;
private tryFindDefaultConfiguredProjectForOpenScriptInfo;
private isMatchedByConfig;
private tryFindDefaultConfiguredProjectForOpenScriptInfoOrClosedFileInfo;
private tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo;
private ensureProjectChildren;
private cleanupConfiguredProjects;
private cleanupProjectsAndScriptInfos;
private tryInvokeWildCardDirectories;
openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult;
private removeOrphanScriptInfos;
private telemetryOnOpenFile;
/**
* Close file whose contents is managed by the client
* @param filename is absolute pathname
*/
closeClientFile(uncheckedFileName: string): void;
private collectChanges;
closeExternalProject(uncheckedFileName: string): void;
openExternalProjects(projects: protocol.ExternalProject[]): void;
private static readonly filenameEscapeRegexp;
private static escapeFilenameForRegex;
resetSafeList(): void;
applySafeList(proj: protocol.ExternalProject): NormalizedPath[];
private applySafeListWorker;
openExternalProject(proj: protocol.ExternalProject): void;
hasDeferredExtension(): boolean;
private endEnablePlugin;
private enableRequestedPluginsAsync;
private enableRequestedPluginsWorker;
configurePlugin(args: protocol.ConfigurePluginRequestArguments): void;
private watchPackageJsonFile;
private onPackageJsonChange;
}
function formatMessage(msg: T, logger: Logger, byteLength: (s: string, encoding: BufferEncoding) => number, newLine: string): string;
interface ServerCancellationToken extends HostCancellationToken {
setRequest(requestId: number): void;
resetRequest(requestId: number): void;
}
const nullCancellationToken: ServerCancellationToken;
/** @deprecated use ts.server.protocol.CommandTypes */
type CommandNames = protocol.CommandTypes;
/** @deprecated use ts.server.protocol.CommandTypes */
const CommandNames: any;
type Event = (body: T, eventName: string) => void;
interface EventSender {
event: Event;
}
interface SessionOptions {
host: ServerHost;
cancellationToken: ServerCancellationToken;
useSingleInferredProject: boolean;
useInferredProjectPerProjectRoot: boolean;
typingsInstaller?: ITypingsInstaller;
byteLength: (buf: string, encoding?: BufferEncoding) => number;
hrtime: (start?: [
number,
number,
]) => [
number,
number,
];
logger: Logger;
/**
* If falsy, all events are suppressed.
*/
canUseEvents: boolean;
canUseWatchEvents?: boolean;
eventHandler?: ProjectServiceEventHandler;
/** Has no effect if eventHandler is also specified. */
suppressDiagnosticEvents?: boolean;
serverMode?: LanguageServiceMode;
throttleWaitMilliseconds?: number;
noGetErrOnBackgroundUpdate?: boolean;
globalPlugins?: readonly string[];
pluginProbeLocations?: readonly string[];
allowLocalPluginLoads?: boolean;
typesMapLocation?: string;
}
class Session implements EventSender {
private readonly gcTimer;
protected projectService: ProjectService;
private changeSeq;
private performanceData;
private currentRequestId;
private errorCheck;
protected host: ServerHost;
private readonly cancellationToken;
protected readonly typingsInstaller: ITypingsInstaller;
protected byteLength: (buf: string, encoding?: BufferEncoding) => number;
private hrtime;
protected logger: Logger;
protected canUseEvents: boolean;
private suppressDiagnosticEvents?;
private eventHandler;
private readonly noGetErrOnBackgroundUpdate?;
constructor(opts: SessionOptions);
private sendRequestCompletedEvent;
private addPerformanceData;
private addDiagnosticsPerformanceData;
private performanceEventHandler;
private defaultEventHandler;
private projectsUpdatedInBackgroundEvent;
logError(err: Error, cmd: string): void;
private logErrorWorker;
send(msg: protocol.Message): void;
protected writeMessage(msg: protocol.Message): void;
event(body: T, eventName: string): void;
private semanticCheck;
private syntacticCheck;
private suggestionCheck;
private regionSemanticCheck;
private sendDiagnosticsEvent;
private updateErrorCheck;
private cleanProjects;
private cleanup;
private getEncodedSyntacticClassifications;
private getEncodedSemanticClassifications;
private getProject;
private getConfigFileAndProject;
private getConfigFileDiagnostics;
private convertToDiagnosticsWithLinePositionFromDiagnosticFile;
private getCompilerOptionsDiagnostics;
private convertToDiagnosticsWithLinePosition;
private getDiagnosticsWorker;
private getDefinition;
private mapDefinitionInfoLocations;
private getDefinitionAndBoundSpan;
private findSourceDefinition;
private getEmitOutput;
private mapJSDocTagInfo;
private mapDisplayParts;
private mapSignatureHelpItems;
private mapDefinitionInfo;
private static mapToOriginalLocation;
private toFileSpan;
private toFileSpanWithContext;
private getTypeDefinition;
private mapImplementationLocations;
private getImplementation;
private getSyntacticDiagnosticsSync;
private getSemanticDiagnosticsSync;
private getSuggestionDiagnosticsSync;
private getJsxClosingTag;
private getLinkedEditingRange;
private getDocumentHighlights;
private provideInlayHints;
private mapCode;
private getCopilotRelatedInfo;
private setCompilerOptionsForInferredProjects;
private getProjectInfo;
private getProjectInfoWorker;
private getDefaultConfiguredProjectInfo;
private getRenameInfo;
private getProjects;
private getDefaultProject;
private getRenameLocations;
private mapRenameInfo;
private toSpanGroups;
private getReferences;
private getFileReferences;
private openClientFile;
private getPosition;
private getPositionInFile;
private getFileAndProject;
private getFileAndLanguageServiceForSyntacticOperation;
private getFileAndProjectWorker;
private getOutliningSpans;
private getTodoComments;
private getDocCommentTemplate;
private getSpanOfEnclosingComment;
private getIndentation;
private getBreakpointStatement;
private getNameOrDottedNameSpan;
private isValidBraceCompletion;
private getQuickInfoWorker;
private getFormattingEditsForRange;
private getFormattingEditsForRangeFull;
private getFormattingEditsForDocumentFull;
private getFormattingEditsAfterKeystrokeFull;
private getFormattingEditsAfterKeystroke;
private getCompletions;
private getCompletionEntryDetails;
private getCompileOnSaveAffectedFileList;
private emitFile;
private getSignatureHelpItems;
private toPendingErrorCheck;
private getDiagnostics;
private change;
private reload;
private saveToTmp;
private closeClientFile;
private mapLocationNavigationBarItems;
private getNavigationBarItems;
private toLocationNavigationTree;
private getNavigationTree;
private getNavigateToItems;
private getFullNavigateToItems;
private getSupportedCodeFixes;
private isLocation;
private extractPositionOrRange;
private getRange;
private getApplicableRefactors;
private getEditsForRefactor;
private getMoveToRefactoringFileSuggestions;
private preparePasteEdits;
private getPasteEdits;
private organizeImports;
private getEditsForFileRename;
private getCodeFixes;
private getCombinedCodeFix;
private applyCodeActionCommand;
private getStartAndEndPosition;
private mapCodeAction;
private mapCodeFixAction;
private mapPasteEditsAction;
private mapTextChangesToCodeEdits;
private mapTextChangeToCodeEdit;
private convertTextChangeToCodeEdit;
private getBraceMatching;
private getDiagnosticsForProject;
private configurePlugin;
private getSmartSelectionRange;
private toggleLineComment;
private toggleMultilineComment;
private commentSelection;
private uncommentSelection;
private mapSelectionRange;
private getScriptInfoFromProjectService;
private toProtocolCallHierarchyItem;
private toProtocolCallHierarchyIncomingCall;
private toProtocolCallHierarchyOutgoingCall;
private prepareCallHierarchy;
private provideCallHierarchyIncomingCalls;
private provideCallHierarchyOutgoingCalls;
getCanonicalFileName(fileName: string): string;
exit(): void;
private notRequired;
private requiredResponse;
private handlers;
addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse): void;
private setCurrentRequest;
private resetCurrentRequest;
executeWithRequestId(requestId: number, f: () => T): T;
executeCommand(request: protocol.Request): HandlerResponse;
onMessage(message: TMessage): void;
protected parseMessage(message: TMessage): protocol.Request;
protected toStringMessage(message: TMessage): string;
private getFormatOptions;
private getPreferences;
private getHostFormatOptions;
private getHostPreferences;
}
interface HandlerResponse {
response?: {};
responseRequired?: boolean;
}
}
namespace JsTyping {
interface TypingResolutionHost {
directoryExists(path: string): boolean;
fileExists(fileName: string): boolean;
readFile(path: string, encoding?: string): string | undefined;
readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[] | undefined, depth?: number): string[];
}
}
const versionMajorMinor = "5.9";
/** The version of the TypeScript compiler release */
const version: string;
/**
* Type of objects whose values are all of the same type.
* The `in` and `for-in` operators can *not* be safely used,
* since `Object.prototype` may be modified by outside code.
*/
interface MapLike {
[index: string]: T;
}
interface SortedReadonlyArray extends ReadonlyArray {
" __sortedArrayBrand": any;
}
interface SortedArray extends Array {
" __sortedArrayBrand": any;
}
type Path = string & {
__pathBrand: any;
};
interface TextRange {
pos: number;
end: number;
}
interface ReadonlyTextRange {
readonly pos: number;
readonly end: number;
}
enum SyntaxKind {
Unknown = 0,
EndOfFileToken = 1,
SingleLineCommentTrivia = 2,
MultiLineCommentTrivia = 3,
NewLineTrivia = 4,
WhitespaceTrivia = 5,
ShebangTrivia = 6,
ConflictMarkerTrivia = 7,
NonTextFileMarkerTrivia = 8,
NumericLiteral = 9,
BigIntLiteral = 10,
StringLiteral = 11,
JsxText = 12,
JsxTextAllWhiteSpaces = 13,
RegularExpressionLiteral = 14,
NoSubstitutionTemplateLiteral = 15,
TemplateHead = 16,
TemplateMiddle = 17,
TemplateTail = 18,
OpenBraceToken = 19,
CloseBraceToken = 20,
OpenParenToken = 21,
CloseParenToken = 22,
OpenBracketToken = 23,
CloseBracketToken = 24,
DotToken = 25,
DotDotDotToken = 26,
SemicolonToken = 27,
CommaToken = 28,
QuestionDotToken = 29,
LessThanToken = 30,
LessThanSlashToken = 31,
GreaterThanToken = 32,
LessThanEqualsToken = 33,
GreaterThanEqualsToken = 34,
EqualsEqualsToken = 35,
ExclamationEqualsToken = 36,
EqualsEqualsEqualsToken = 37,
ExclamationEqualsEqualsToken = 38,
EqualsGreaterThanToken = 39,
PlusToken = 40,
MinusToken = 41,
AsteriskToken = 42,
AsteriskAsteriskToken = 43,
SlashToken = 44,
PercentToken = 45,
PlusPlusToken = 46,
MinusMinusToken = 47,
LessThanLessThanToken = 48,
GreaterThanGreaterThanToken = 49,
GreaterThanGreaterThanGreaterThanToken = 50,
AmpersandToken = 51,
BarToken = 52,
CaretToken = 53,
ExclamationToken = 54,
TildeToken = 55,
AmpersandAmpersandToken = 56,
BarBarToken = 57,
QuestionToken = 58,
ColonToken = 59,
AtToken = 60,
QuestionQuestionToken = 61,
/** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */
BacktickToken = 62,
/** Only the JSDoc scanner produces HashToken. The normal scanner produces PrivateIdentifier. */
HashToken = 63,
EqualsToken = 64,
PlusEqualsToken = 65,
MinusEqualsToken = 66,
AsteriskEqualsToken = 67,
AsteriskAsteriskEqualsToken = 68,
SlashEqualsToken = 69,
PercentEqualsToken = 70,
LessThanLessThanEqualsToken = 71,
GreaterThanGreaterThanEqualsToken = 72,
GreaterThanGreaterThanGreaterThanEqualsToken = 73,
AmpersandEqualsToken = 74,
BarEqualsToken = 75,
BarBarEqualsToken = 76,
AmpersandAmpersandEqualsToken = 77,
QuestionQuestionEqualsToken = 78,
CaretEqualsToken = 79,
Identifier = 80,
PrivateIdentifier = 81,
BreakKeyword = 83,
CaseKeyword = 84,
CatchKeyword = 85,
ClassKeyword = 86,
ConstKeyword = 87,
ContinueKeyword = 88,
DebuggerKeyword = 89,
DefaultKeyword = 90,
DeleteKeyword = 91,
DoKeyword = 92,
ElseKeyword = 93,
EnumKeyword = 94,
ExportKeyword = 95,
ExtendsKeyword = 96,
FalseKeyword = 97,
FinallyKeyword = 98,
ForKeyword = 99,
FunctionKeyword = 100,
IfKeyword = 101,
ImportKeyword = 102,
InKeyword = 103,
InstanceOfKeyword = 104,
NewKeyword = 105,
NullKeyword = 106,
ReturnKeyword = 107,
SuperKeyword = 108,
SwitchKeyword = 109,
ThisKeyword = 110,
ThrowKeyword = 111,
TrueKeyword = 112,
TryKeyword = 113,
TypeOfKeyword = 114,
VarKeyword = 115,
VoidKeyword = 116,
WhileKeyword = 117,
WithKeyword = 118,
ImplementsKeyword = 119,
InterfaceKeyword = 120,
LetKeyword = 121,
PackageKeyword = 122,
PrivateKeyword = 123,
ProtectedKeyword = 124,
PublicKeyword = 125,
StaticKeyword = 126,
YieldKeyword = 127,
AbstractKeyword = 128,
AccessorKeyword = 129,
AsKeyword = 130,
AssertsKeyword = 131,
AssertKeyword = 132,
AnyKeyword = 133,
AsyncKeyword = 134,
AwaitKeyword = 135,
BooleanKeyword = 136,
ConstructorKeyword = 137,
DeclareKeyword = 138,
GetKeyword = 139,
InferKeyword = 140,
IntrinsicKeyword = 141,
IsKeyword = 142,
KeyOfKeyword = 143,
ModuleKeyword = 144,
NamespaceKeyword = 145,
NeverKeyword = 146,
OutKeyword = 147,
ReadonlyKeyword = 148,
RequireKeyword = 149,
NumberKeyword = 150,
ObjectKeyword = 151,
SatisfiesKeyword = 152,
SetKeyword = 153,
StringKeyword = 154,
SymbolKeyword = 155,
TypeKeyword = 156,
UndefinedKeyword = 157,
UniqueKeyword = 158,
UnknownKeyword = 159,
UsingKeyword = 160,
FromKeyword = 161,
GlobalKeyword = 162,
BigIntKeyword = 163,
OverrideKeyword = 164,
OfKeyword = 165,
DeferKeyword = 166,
QualifiedName = 167,
ComputedPropertyName = 168,
TypeParameter = 169,
Parameter = 170,
Decorator = 171,
PropertySignature = 172,
PropertyDeclaration = 173,
MethodSignature = 174,
MethodDeclaration = 175,
ClassStaticBlockDeclaration = 176,
Constructor = 177,
GetAccessor = 178,
SetAccessor = 179,
CallSignature = 180,
ConstructSignature = 181,
IndexSignature = 182,
TypePredicate = 183,
TypeReference = 184,
FunctionType = 185,
ConstructorType = 186,
TypeQuery = 187,
TypeLiteral = 188,
ArrayType = 189,
TupleType = 190,
OptionalType = 191,
RestType = 192,
UnionType = 193,
IntersectionType = 194,
ConditionalType = 195,
InferType = 196,
ParenthesizedType = 197,
ThisType = 198,
TypeOperator = 199,
IndexedAccessType = 200,
MappedType = 201,
LiteralType = 202,
NamedTupleMember = 203,
TemplateLiteralType = 204,
TemplateLiteralTypeSpan = 205,
ImportType = 206,
ObjectBindingPattern = 207,
ArrayBindingPattern = 208,
BindingElement = 209,
ArrayLiteralExpression = 210,
ObjectLiteralExpression = 211,
PropertyAccessExpression = 212,
ElementAccessExpression = 213,
CallExpression = 214,
NewExpression = 215,
TaggedTemplateExpression = 216,
TypeAssertionExpression = 217,
ParenthesizedExpression = 218,
FunctionExpression = 219,
ArrowFunction = 220,
DeleteExpression = 221,
TypeOfExpression = 222,
VoidExpression = 223,
AwaitExpression = 224,
PrefixUnaryExpression = 225,
PostfixUnaryExpression = 226,
BinaryExpression = 227,
ConditionalExpression = 228,
TemplateExpression = 229,
YieldExpression = 230,
SpreadElement = 231,
ClassExpression = 232,
OmittedExpression = 233,
ExpressionWithTypeArguments = 234,
AsExpression = 235,
NonNullExpression = 236,
MetaProperty = 237,
SyntheticExpression = 238,
SatisfiesExpression = 239,
TemplateSpan = 240,
SemicolonClassElement = 241,
Block = 242,
EmptyStatement = 243,
VariableStatement = 244,
ExpressionStatement = 245,
IfStatement = 246,
DoStatement = 247,
WhileStatement = 248,
ForStatement = 249,
ForInStatement = 250,
ForOfStatement = 251,
ContinueStatement = 252,
BreakStatement = 253,
ReturnStatement = 254,
WithStatement = 255,
SwitchStatement = 256,
LabeledStatement = 257,
ThrowStatement = 258,
TryStatement = 259,
DebuggerStatement = 260,
VariableDeclaration = 261,
VariableDeclarationList = 262,
FunctionDeclaration = 263,
ClassDeclaration = 264,
InterfaceDeclaration = 265,
TypeAliasDeclaration = 266,
EnumDeclaration = 267,
ModuleDeclaration = 268,
ModuleBlock = 269,
CaseBlock = 270,
NamespaceExportDeclaration = 271,
ImportEqualsDeclaration = 272,
ImportDeclaration = 273,
ImportClause = 274,
NamespaceImport = 275,
NamedImports = 276,
ImportSpecifier = 277,
ExportAssignment = 278,
ExportDeclaration = 279,
NamedExports = 280,
NamespaceExport = 281,
ExportSpecifier = 282,
MissingDeclaration = 283,
ExternalModuleReference = 284,
JsxElement = 285,
JsxSelfClosingElement = 286,
JsxOpeningElement = 287,
JsxClosingElement = 288,
JsxFragment = 289,
JsxOpeningFragment = 290,
JsxClosingFragment = 291,
JsxAttribute = 292,
JsxAttributes = 293,
JsxSpreadAttribute = 294,
JsxExpression = 295,
JsxNamespacedName = 296,
CaseClause = 297,
DefaultClause = 298,
HeritageClause = 299,
CatchClause = 300,
ImportAttributes = 301,
ImportAttribute = 302,
/** @deprecated */ AssertClause = 301,
/** @deprecated */ AssertEntry = 302,
/** @deprecated */ ImportTypeAssertionContainer = 303,
PropertyAssignment = 304,
ShorthandPropertyAssignment = 305,
SpreadAssignment = 306,
EnumMember = 307,
SourceFile = 308,
Bundle = 309,
JSDocTypeExpression = 310,
JSDocNameReference = 311,
JSDocMemberName = 312,
JSDocAllType = 313,
JSDocUnknownType = 314,
JSDocNullableType = 315,
JSDocNonNullableType = 316,
JSDocOptionalType = 317,
JSDocFunctionType = 318,
JSDocVariadicType = 319,
JSDocNamepathType = 320,
JSDoc = 321,
/** @deprecated Use SyntaxKind.JSDoc */
JSDocComment = 321,
JSDocText = 322,
JSDocTypeLiteral = 323,
JSDocSignature = 324,
JSDocLink = 325,
JSDocLinkCode = 326,
JSDocLinkPlain = 327,
JSDocTag = 328,
JSDocAugmentsTag = 329,
JSDocImplementsTag = 330,
JSDocAuthorTag = 331,
JSDocDeprecatedTag = 332,
JSDocClassTag = 333,
JSDocPublicTag = 334,
JSDocPrivateTag = 335,
JSDocProtectedTag = 336,
JSDocReadonlyTag = 337,
JSDocOverrideTag = 338,
JSDocCallbackTag = 339,
JSDocOverloadTag = 340,
JSDocEnumTag = 341,
JSDocParameterTag = 342,
JSDocReturnTag = 343,
JSDocThisTag = 344,
JSDocTypeTag = 345,
JSDocTemplateTag = 346,
JSDocTypedefTag = 347,
JSDocSeeTag = 348,
JSDocPropertyTag = 349,
JSDocThrowsTag = 350,
JSDocSatisfiesTag = 351,
JSDocImportTag = 352,
SyntaxList = 353,
NotEmittedStatement = 354,
NotEmittedTypeElement = 355,
PartiallyEmittedExpression = 356,
CommaListExpression = 357,
SyntheticReferenceExpression = 358,
Count = 359,
FirstAssignment = 64,
LastAssignment = 79,
FirstCompoundAssignment = 65,
LastCompoundAssignment = 79,
FirstReservedWord = 83,
LastReservedWord = 118,
FirstKeyword = 83,
LastKeyword = 166,
FirstFutureReservedWord = 119,
LastFutureReservedWord = 127,
FirstTypeNode = 183,
LastTypeNode = 206,
FirstPunctuation = 19,
LastPunctuation = 79,
FirstToken = 0,
LastToken = 166,
FirstTriviaToken = 2,
LastTriviaToken = 7,
FirstLiteralToken = 9,
LastLiteralToken = 15,
FirstTemplateToken = 15,
LastTemplateToken = 18,
FirstBinaryOperator = 30,
LastBinaryOperator = 79,
FirstStatement = 244,
LastStatement = 260,
FirstNode = 167,
FirstJSDocNode = 310,
LastJSDocNode = 352,
FirstJSDocTagNode = 328,
LastJSDocTagNode = 352,
}
type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia;
type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral;
type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail;
type PunctuationSyntaxKind =
| SyntaxKind.OpenBraceToken
| SyntaxKind.CloseBraceToken
| SyntaxKind.OpenParenToken
| SyntaxKind.CloseParenToken
| SyntaxKind.OpenBracketToken
| SyntaxKind.CloseBracketToken
| SyntaxKind.DotToken
| SyntaxKind.DotDotDotToken
| SyntaxKind.SemicolonToken
| SyntaxKind.CommaToken
| SyntaxKind.QuestionDotToken
| SyntaxKind.LessThanToken
| SyntaxKind.LessThanSlashToken
| SyntaxKind.GreaterThanToken
| SyntaxKind.LessThanEqualsToken
| SyntaxKind.GreaterThanEqualsToken
| SyntaxKind.EqualsEqualsToken
| SyntaxKind.ExclamationEqualsToken
| SyntaxKind.EqualsEqualsEqualsToken
| SyntaxKind.ExclamationEqualsEqualsToken
| SyntaxKind.EqualsGreaterThanToken
| SyntaxKind.PlusToken
| SyntaxKind.MinusToken
| SyntaxKind.AsteriskToken
| SyntaxKind.AsteriskAsteriskToken
| SyntaxKind.SlashToken
| SyntaxKind.PercentToken
| SyntaxKind.PlusPlusToken
| SyntaxKind.MinusMinusToken
| SyntaxKind.LessThanLessThanToken
| SyntaxKind.GreaterThanGreaterThanToken
| SyntaxKind.GreaterThanGreaterThanGreaterThanToken
| SyntaxKind.AmpersandToken
| SyntaxKind.BarToken
| SyntaxKind.CaretToken
| SyntaxKind.ExclamationToken
| SyntaxKind.TildeToken
| SyntaxKind.AmpersandAmpersandToken
| SyntaxKind.AmpersandAmpersandEqualsToken
| SyntaxKind.BarBarToken
| SyntaxKind.BarBarEqualsToken
| SyntaxKind.QuestionQuestionToken
| SyntaxKind.QuestionQuestionEqualsToken
| SyntaxKind.QuestionToken
| SyntaxKind.ColonToken
| SyntaxKind.AtToken
| SyntaxKind.BacktickToken
| SyntaxKind.HashToken
| SyntaxKind.EqualsToken
| SyntaxKind.PlusEqualsToken
| SyntaxKind.MinusEqualsToken
| SyntaxKind.AsteriskEqualsToken
| SyntaxKind.AsteriskAsteriskEqualsToken
| SyntaxKind.SlashEqualsToken
| SyntaxKind.PercentEqualsToken
| SyntaxKind.LessThanLessThanEqualsToken
| SyntaxKind.GreaterThanGreaterThanEqualsToken
| SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken
| SyntaxKind.AmpersandEqualsToken
| SyntaxKind.BarEqualsToken
| SyntaxKind.CaretEqualsToken;
type KeywordSyntaxKind =
| SyntaxKind.AbstractKeyword
| SyntaxKind.AccessorKeyword
| SyntaxKind.AnyKeyword
| SyntaxKind.AsKeyword
| SyntaxKind.AssertsKeyword
| SyntaxKind.AssertKeyword
| SyntaxKind.AsyncKeyword
| SyntaxKind.AwaitKeyword
| SyntaxKind.BigIntKeyword
| SyntaxKind.BooleanKeyword
| SyntaxKind.BreakKeyword
| SyntaxKind.CaseKeyword
| SyntaxKind.CatchKeyword
| SyntaxKind.ClassKeyword
| SyntaxKind.ConstKeyword
| SyntaxKind.ConstructorKeyword
| SyntaxKind.ContinueKeyword
| SyntaxKind.DebuggerKeyword
| SyntaxKind.DeclareKeyword
| SyntaxKind.DefaultKeyword
| SyntaxKind.DeferKeyword
| SyntaxKind.DeleteKeyword
| SyntaxKind.DoKeyword
| SyntaxKind.ElseKeyword
| SyntaxKind.EnumKeyword
| SyntaxKind.ExportKeyword
| SyntaxKind.ExtendsKeyword
| SyntaxKind.FalseKeyword
| SyntaxKind.FinallyKeyword
| SyntaxKind.ForKeyword
| SyntaxKind.FromKeyword
| SyntaxKind.FunctionKeyword
| SyntaxKind.GetKeyword
| SyntaxKind.GlobalKeyword
| SyntaxKind.IfKeyword
| SyntaxKind.ImplementsKeyword
| SyntaxKind.ImportKeyword
| SyntaxKind.InferKeyword
| SyntaxKind.InKeyword
| SyntaxKind.InstanceOfKeyword
| SyntaxKind.InterfaceKeyword
| SyntaxKind.IntrinsicKeyword
| SyntaxKind.IsKeyword
| SyntaxKind.KeyOfKeyword
| SyntaxKind.LetKeyword
| SyntaxKind.ModuleKeyword
| SyntaxKind.NamespaceKeyword
| SyntaxKind.NeverKeyword
| SyntaxKind.NewKeyword
| SyntaxKind.NullKeyword
| SyntaxKind.NumberKeyword
| SyntaxKind.ObjectKeyword
| SyntaxKind.OfKeyword
| SyntaxKind.PackageKeyword
| SyntaxKind.PrivateKeyword
| SyntaxKind.ProtectedKeyword
| SyntaxKind.PublicKeyword
| SyntaxKind.ReadonlyKeyword
| SyntaxKind.OutKeyword
| SyntaxKind.OverrideKeyword
| SyntaxKind.RequireKeyword
| SyntaxKind.ReturnKeyword
| SyntaxKind.SatisfiesKeyword
| SyntaxKind.SetKeyword
| SyntaxKind.StaticKeyword
| SyntaxKind.StringKeyword
| SyntaxKind.SuperKeyword
| SyntaxKind.SwitchKeyword
| SyntaxKind.SymbolKeyword
| SyntaxKind.ThisKeyword
| SyntaxKind.ThrowKeyword
| SyntaxKind.TrueKeyword
| SyntaxKind.TryKeyword
| SyntaxKind.TypeKeyword
| SyntaxKind.TypeOfKeyword
| SyntaxKind.UndefinedKeyword
| SyntaxKind.UniqueKeyword
| SyntaxKind.UnknownKeyword
| SyntaxKind.UsingKeyword
| SyntaxKind.VarKeyword
| SyntaxKind.VoidKeyword
| SyntaxKind.WhileKeyword
| SyntaxKind.WithKeyword
| SyntaxKind.YieldKeyword;
type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword;
type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword;
type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind;
type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.Unknown | KeywordSyntaxKind;
enum NodeFlags {
None = 0,
Let = 1,
Const = 2,
Using = 4,
AwaitUsing = 6,
NestedNamespace = 8,
Synthesized = 16,
Namespace = 32,
OptionalChain = 64,
ExportContext = 128,
ContainsThis = 256,
HasImplicitReturn = 512,
HasExplicitReturn = 1024,
GlobalAugmentation = 2048,
HasAsyncFunctions = 4096,
DisallowInContext = 8192,
YieldContext = 16384,
DecoratorContext = 32768,
AwaitContext = 65536,
DisallowConditionalTypesContext = 131072,
ThisNodeHasError = 262144,
JavaScriptFile = 524288,
ThisNodeOrAnySubNodesHasError = 1048576,
HasAggregatedChildData = 2097152,
JSDoc = 16777216,
JsonFile = 134217728,
BlockScoped = 7,
Constant = 6,
ReachabilityCheckFlags = 1536,
ReachabilityAndEmitFlags = 5632,
ContextFlags = 101441536,
TypeExcludesFlags = 81920,
}
enum ModifierFlags {
None = 0,
Public = 1,
Private = 2,
Protected = 4,
Readonly = 8,
Override = 16,
Export = 32,
Abstract = 64,
Ambient = 128,
Static = 256,
Accessor = 512,
Async = 1024,
Default = 2048,
Const = 4096,
In = 8192,
Out = 16384,
Decorator = 32768,
Deprecated = 65536,
HasComputedJSDocModifiers = 268435456,
HasComputedFlags = 536870912,
AccessibilityModifier = 7,
ParameterPropertyModifier = 31,
NonPublicAccessibilityModifier = 6,
TypeScriptModifier = 28895,
ExportDefault = 2080,
All = 131071,
Modifier = 98303,
}
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,
}
interface Node extends ReadonlyTextRange {
readonly kind: SyntaxKind;
readonly flags: NodeFlags;
readonly parent: Node;
}
interface Node {
getSourceFile(): SourceFile;
getChildCount(sourceFile?: SourceFile): number;
getChildAt(index: number, sourceFile?: SourceFile): Node;
getChildren(sourceFile?: SourceFile): readonly Node[];
getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): 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?: SourceFile): Node | undefined;
getLastToken(sourceFile?: SourceFile): Node | undefined;
forEachChild(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray) => T | undefined): T | undefined;
}
interface JSDocContainer extends Node {
_jsdocContainerBrand: any;
}
interface LocalsContainer extends Node {
_localsContainerBrand: any;
}
interface FlowContainer extends Node {
_flowContainerBrand: any;
}
type HasJSDoc =
| AccessorDeclaration
| ArrowFunction
| BinaryExpression
| Block
| BreakStatement
| CallSignatureDeclaration
| CaseClause
| ClassLikeDeclaration
| ClassStaticBlockDeclaration
| ConstructorDeclaration
| ConstructorTypeNode
| ConstructSignatureDeclaration
| ContinueStatement
| DebuggerStatement
| DoStatement
| ElementAccessExpression
| EmptyStatement
| EndOfFileToken
| EnumDeclaration
| EnumMember
| ExportAssignment
| ExportDeclaration
| ExportSpecifier
| ExpressionStatement
| ForInStatement
| ForOfStatement
| ForStatement
| FunctionDeclaration
| FunctionExpression
| FunctionTypeNode
| Identifier
| IfStatement
| ImportDeclaration
| ImportEqualsDeclaration
| IndexSignatureDeclaration
| InterfaceDeclaration
| JSDocFunctionType
| JSDocSignature
| LabeledStatement
| MethodDeclaration
| MethodSignature
| ModuleDeclaration
| NamedTupleMember
| NamespaceExportDeclaration
| ObjectLiteralExpression
| ParameterDeclaration
| ParenthesizedExpression
| PropertyAccessExpression
| PropertyAssignment
| PropertyDeclaration
| PropertySignature
| ReturnStatement
| SemicolonClassElement
| ShorthandPropertyAssignment
| SpreadAssignment
| SwitchStatement
| ThrowStatement
| TryStatement
| TypeAliasDeclaration
| TypeParameterDeclaration
| VariableDeclaration
| VariableStatement
| WhileStatement
| WithStatement;
type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | EnumMember;
type HasDecorators = ParameterDeclaration | PropertyDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ClassExpression | ClassDeclaration;
type HasModifiers = TypeParameterDeclaration | ParameterDeclaration | ConstructorTypeNode | PropertySignature | PropertyDeclaration | MethodSignature | MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | IndexSignatureDeclaration | FunctionExpression | ArrowFunction | ClassExpression | VariableStatement | FunctionDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | ExportAssignment | ExportDeclaration;
interface NodeArray extends ReadonlyArray, ReadonlyTextRange {
readonly hasTrailingComma: boolean;
}
interface Token extends Node {
readonly kind: TKind;
}
type EndOfFileToken = Token & JSDocContainer;
interface PunctuationToken extends Token {
}
type DotToken = PunctuationToken;
type DotDotDotToken = PunctuationToken;
type QuestionToken = PunctuationToken;
type ExclamationToken = PunctuationToken;
type ColonToken = PunctuationToken;
type EqualsToken = PunctuationToken;
type AmpersandAmpersandEqualsToken = PunctuationToken;
type BarBarEqualsToken = PunctuationToken;
type QuestionQuestionEqualsToken = PunctuationToken;
type AsteriskToken = PunctuationToken;
type EqualsGreaterThanToken = PunctuationToken;
type PlusToken = PunctuationToken;
type MinusToken = PunctuationToken;
type QuestionDotToken = PunctuationToken;
interface KeywordToken extends Token {
}
type AssertsKeyword = KeywordToken;
type AssertKeyword = KeywordToken;
type AwaitKeyword = KeywordToken;
type CaseKeyword = KeywordToken;
interface ModifierToken extends KeywordToken {
}
type AbstractKeyword = ModifierToken;
type AccessorKeyword = ModifierToken;
type AsyncKeyword = ModifierToken;
type ConstKeyword = ModifierToken;
type DeclareKeyword = ModifierToken;
type DefaultKeyword = ModifierToken;
type ExportKeyword = ModifierToken;
type InKeyword = ModifierToken;
type PrivateKeyword = ModifierToken;
type ProtectedKeyword = ModifierToken;
type PublicKeyword = ModifierToken;
type ReadonlyKeyword = ModifierToken;
type OutKeyword = ModifierToken;
type OverrideKeyword = ModifierToken;
type StaticKeyword = ModifierToken;
type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword;
type ModifierLike = Modifier | Decorator;
type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword;
type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword;
type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword | AccessorKeyword;
type ModifiersArray = NodeArray;
enum GeneratedIdentifierFlags {
None = 0,
ReservedInNestedScopes = 8,
Optimistic = 16,
FileLevel = 32,
AllowNameSubstitution = 64,
}
interface Identifier extends PrimaryExpression, Declaration, JSDocContainer, FlowContainer {
readonly 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.
*/
readonly escapedText: __String;
}
interface Identifier {
readonly text: string;
}
interface TransientIdentifier extends Identifier {
resolvedSymbol: Symbol;
}
interface QualifiedName extends Node, FlowContainer {
readonly kind: SyntaxKind.QualifiedName;
readonly left: EntityName;
readonly right: Identifier;
}
type EntityName = Identifier | QualifiedName;
type PropertyName = Identifier | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier | BigIntLiteral;
type MemberName = Identifier | PrivateIdentifier;
type DeclarationName = PropertyName | JsxAttributeName | StringLiteralLike | ElementAccessExpression | BindingPattern | EntityNameExpression;
interface Declaration extends Node {
_declarationBrand: any;
}
interface NamedDeclaration extends Declaration {
readonly name?: DeclarationName;
}
interface DeclarationStatement extends NamedDeclaration, Statement {
readonly name?: Identifier | StringLiteral | NumericLiteral;
}
interface ComputedPropertyName extends Node {
readonly kind: SyntaxKind.ComputedPropertyName;
readonly parent: Declaration;
readonly expression: Expression;
}
interface PrivateIdentifier extends PrimaryExpression {
readonly kind: SyntaxKind.PrivateIdentifier;
readonly escapedText: __String;
}
interface PrivateIdentifier {
readonly text: string;
}
interface Decorator extends Node {
readonly kind: SyntaxKind.Decorator;
readonly parent: NamedDeclaration;
readonly expression: LeftHandSideExpression;
}
interface TypeParameterDeclaration extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.TypeParameter;
readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode;
readonly modifiers?: NodeArray;
readonly name: Identifier;
/** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */
readonly constraint?: TypeNode;
readonly default?: TypeNode;
expression?: Expression;
}
interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {
readonly kind: SignatureDeclaration["kind"];
readonly name?: PropertyName;
readonly typeParameters?: NodeArray | undefined;
readonly parameters: NodeArray;
readonly type?: TypeNode | undefined;
}
type SignatureDeclaration = CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | AccessorDeclaration | FunctionExpression | ArrowFunction;
interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement, LocalsContainer {
readonly kind: SyntaxKind.CallSignature;
}
interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement, LocalsContainer {
readonly kind: SyntaxKind.ConstructSignature;
}
type BindingName = Identifier | BindingPattern;
interface VariableDeclaration extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.VariableDeclaration;
readonly parent: VariableDeclarationList | CatchClause;
readonly name: BindingName;
readonly exclamationToken?: ExclamationToken;
readonly type?: TypeNode;
readonly initializer?: Expression;
}
interface VariableDeclarationList extends Node {
readonly kind: SyntaxKind.VariableDeclarationList;
readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;
readonly declarations: NodeArray;
}
interface ParameterDeclaration extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.Parameter;
readonly parent: SignatureDeclaration;
readonly modifiers?: NodeArray;
readonly dotDotDotToken?: DotDotDotToken;
readonly name: BindingName;
readonly questionToken?: QuestionToken;
readonly type?: TypeNode;
readonly initializer?: Expression;
}
interface BindingElement extends NamedDeclaration, FlowContainer {
readonly kind: SyntaxKind.BindingElement;
readonly parent: BindingPattern;
readonly propertyName?: PropertyName;
readonly dotDotDotToken?: DotDotDotToken;
readonly name: BindingName;
readonly initializer?: Expression;
}
interface PropertySignature extends TypeElement, JSDocContainer {
readonly kind: SyntaxKind.PropertySignature;
readonly parent: TypeLiteralNode | InterfaceDeclaration;
readonly modifiers?: NodeArray;
readonly name: PropertyName;
readonly questionToken?: QuestionToken;
readonly type?: TypeNode;
}
interface PropertyDeclaration extends ClassElement, JSDocContainer {
readonly kind: SyntaxKind.PropertyDeclaration;
readonly parent: ClassLikeDeclaration;
readonly modifiers?: NodeArray;
readonly name: PropertyName;
readonly questionToken?: QuestionToken;
readonly exclamationToken?: ExclamationToken;
readonly type?: TypeNode;
readonly initializer?: Expression;
}
interface AutoAccessorPropertyDeclaration extends PropertyDeclaration {
_autoAccessorBrand: any;
}
interface ObjectLiteralElement extends NamedDeclaration {
_objectLiteralBrand: any;
readonly name?: PropertyName;
}
/** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */
type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration;
interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.PropertyAssignment;
readonly parent: ObjectLiteralExpression;
readonly name: PropertyName;
readonly initializer: Expression;
}
interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.ShorthandPropertyAssignment;
readonly parent: ObjectLiteralExpression;
readonly name: Identifier;
readonly equalsToken?: EqualsToken;
readonly objectAssignmentInitializer?: Expression;
}
interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.SpreadAssignment;
readonly parent: ObjectLiteralExpression;
readonly expression: Expression;
}
type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag;
interface ObjectBindingPattern extends Node {
readonly kind: SyntaxKind.ObjectBindingPattern;
readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
readonly elements: NodeArray;
}
interface ArrayBindingPattern extends Node {
readonly kind: SyntaxKind.ArrayBindingPattern;
readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
readonly elements: NodeArray;
}
type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
type ArrayBindingElement = BindingElement | OmittedExpression;
/**
* Several node kinds share function-like features such as a signature,
* a name, and a body. These nodes should extend FunctionLikeDeclarationBase.
* Examples:
* - FunctionDeclaration
* - MethodDeclaration
* - AccessorDeclaration
*/
interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
_functionLikeDeclarationBrand: any;
readonly asteriskToken?: AsteriskToken | undefined;
readonly questionToken?: QuestionToken | undefined;
readonly exclamationToken?: ExclamationToken | undefined;
readonly body?: Block | Expression | undefined;
}
type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;
/** @deprecated Use SignatureDeclaration */
type FunctionLike = SignatureDeclaration;
interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement, LocalsContainer {
readonly kind: SyntaxKind.FunctionDeclaration;
readonly modifiers?: NodeArray;
readonly name?: Identifier;
readonly body?: FunctionBody;
}
interface MethodSignature extends SignatureDeclarationBase, TypeElement, LocalsContainer {
readonly kind: SyntaxKind.MethodSignature;
readonly parent: TypeLiteralNode | InterfaceDeclaration;
readonly modifiers?: NodeArray;
readonly name: PropertyName;
}
interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.MethodDeclaration;
readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;
readonly modifiers?: NodeArray | undefined;
readonly name: PropertyName;
readonly body?: FunctionBody | undefined;
}
interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer, LocalsContainer {
readonly kind: SyntaxKind.Constructor;
readonly parent: ClassLikeDeclaration;
readonly modifiers?: NodeArray | undefined;
readonly body?: FunctionBody | undefined;
}
/** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
interface SemicolonClassElement extends ClassElement, JSDocContainer {
readonly kind: SyntaxKind.SemicolonClassElement;
readonly parent: ClassLikeDeclaration;
}
interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.GetAccessor;
readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
readonly modifiers?: NodeArray;
readonly name: PropertyName;
readonly body?: FunctionBody;
}
interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.SetAccessor;
readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
readonly modifiers?: NodeArray;
readonly name: PropertyName;
readonly body?: FunctionBody;
}
type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement, LocalsContainer {
readonly kind: SyntaxKind.IndexSignature;
readonly parent: ObjectTypeDeclaration;
readonly modifiers?: NodeArray;
readonly type: TypeNode;
}
interface ClassStaticBlockDeclaration extends ClassElement, JSDocContainer, LocalsContainer {
readonly kind: SyntaxKind.ClassStaticBlockDeclaration;
readonly parent: ClassDeclaration | ClassExpression;
readonly body: Block;
}
interface TypeNode extends Node {
_typeNodeBrand: any;
}
interface KeywordTypeNode extends KeywordToken, TypeNode {
readonly kind: TKind;
}
/** @deprecated */
interface ImportTypeAssertionContainer extends Node {
readonly kind: SyntaxKind.ImportTypeAssertionContainer;
readonly parent: ImportTypeNode;
/** @deprecated */ readonly assertClause: AssertClause;
readonly multiLine?: boolean;
}
interface ImportTypeNode extends NodeWithTypeArguments {
readonly kind: SyntaxKind.ImportType;
readonly isTypeOf: boolean;
readonly argument: TypeNode;
/** @deprecated */ readonly assertions?: ImportTypeAssertionContainer;
readonly attributes?: ImportAttributes;
readonly qualifier?: EntityName;
}
interface ThisTypeNode extends TypeNode {
readonly kind: SyntaxKind.ThisType;
}
type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;
interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {
readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
readonly type: TypeNode;
}
interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer {
readonly kind: SyntaxKind.FunctionType;
}
interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer {
readonly kind: SyntaxKind.ConstructorType;
readonly modifiers?: NodeArray;
}
interface NodeWithTypeArguments extends TypeNode {
readonly typeArguments?: NodeArray;
}
type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;
interface TypeReferenceNode extends NodeWithTypeArguments {
readonly kind: SyntaxKind.TypeReference;
readonly typeName: EntityName;
}
interface TypePredicateNode extends TypeNode {
readonly kind: SyntaxKind.TypePredicate;
readonly parent: SignatureDeclaration | JSDocTypeExpression;
readonly assertsModifier?: AssertsKeyword;
readonly parameterName: Identifier | ThisTypeNode;
readonly type?: TypeNode;
}
interface TypeQueryNode extends NodeWithTypeArguments {
readonly kind: SyntaxKind.TypeQuery;
readonly exprName: EntityName;
}
interface TypeLiteralNode extends TypeNode, Declaration {
readonly kind: SyntaxKind.TypeLiteral;
readonly members: NodeArray;
}
interface ArrayTypeNode extends TypeNode {
readonly kind: SyntaxKind.ArrayType;
readonly elementType: TypeNode;
}
interface TupleTypeNode extends TypeNode {
readonly kind: SyntaxKind.TupleType;
readonly elements: NodeArray;
}
interface NamedTupleMember extends TypeNode, Declaration, JSDocContainer {
readonly kind: SyntaxKind.NamedTupleMember;
readonly dotDotDotToken?: Token;
readonly name: Identifier;
readonly questionToken?: Token;
readonly type: TypeNode;
}
interface OptionalTypeNode extends TypeNode {
readonly kind: SyntaxKind.OptionalType;
readonly type: TypeNode;
}
interface RestTypeNode extends TypeNode {
readonly kind: SyntaxKind.RestType;
readonly type: TypeNode;
}
type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
interface UnionTypeNode extends TypeNode {
readonly kind: SyntaxKind.UnionType;
readonly types: NodeArray;
}
interface IntersectionTypeNode extends TypeNode {
readonly kind: SyntaxKind.IntersectionType;
readonly types: NodeArray;
}
interface ConditionalTypeNode extends TypeNode, LocalsContainer {
readonly kind: SyntaxKind.ConditionalType;
readonly checkType: TypeNode;
readonly extendsType: TypeNode;
readonly trueType: TypeNode;
readonly falseType: TypeNode;
}
interface InferTypeNode extends TypeNode {
readonly kind: SyntaxKind.InferType;
readonly typeParameter: TypeParameterDeclaration;
}
interface ParenthesizedTypeNode extends TypeNode {
readonly kind: SyntaxKind.ParenthesizedType;
readonly type: TypeNode;
}
interface TypeOperatorNode extends TypeNode {
readonly kind: SyntaxKind.TypeOperator;
readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
readonly type: TypeNode;
}
interface IndexedAccessTypeNode extends TypeNode {
readonly kind: SyntaxKind.IndexedAccessType;
readonly objectType: TypeNode;
readonly indexType: TypeNode;
}
interface MappedTypeNode extends TypeNode, Declaration, LocalsContainer {
readonly kind: SyntaxKind.MappedType;
readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
readonly typeParameter: TypeParameterDeclaration;
readonly nameType?: TypeNode;
readonly questionToken?: QuestionToken | PlusToken | MinusToken;
readonly type?: TypeNode;
/** Used only to produce grammar errors */
readonly members?: NodeArray;
}
interface LiteralTypeNode extends TypeNode {
readonly kind: SyntaxKind.LiteralType;
readonly literal: NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression;
}
interface StringLiteral extends LiteralExpression, Declaration {
readonly kind: SyntaxKind.StringLiteral;
}
type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral | JsxNamespacedName | BigIntLiteral;
interface TemplateLiteralTypeNode extends TypeNode {
kind: SyntaxKind.TemplateLiteralType;
readonly head: TemplateHead;
readonly templateSpans: NodeArray;
}
interface TemplateLiteralTypeSpan extends TypeNode {
readonly kind: SyntaxKind.TemplateLiteralTypeSpan;
readonly parent: TemplateLiteralTypeNode;
readonly type: TypeNode;
readonly literal: TemplateMiddle | TemplateTail;
}
interface Expression extends Node {
_expressionBrand: any;
}
interface OmittedExpression extends Expression {
readonly kind: SyntaxKind.OmittedExpression;
}
interface PartiallyEmittedExpression extends LeftHandSideExpression {
readonly kind: SyntaxKind.PartiallyEmittedExpression;
readonly expression: Expression;
}
interface UnaryExpression extends Expression {
_unaryExpressionBrand: any;
}
/** Deprecated, please use UpdateExpression */
type IncrementExpression = UpdateExpression;
interface UpdateExpression extends UnaryExpression {
_updateExpressionBrand: any;
}
type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
interface PrefixUnaryExpression extends UpdateExpression {
readonly kind: SyntaxKind.PrefixUnaryExpression;
readonly operator: PrefixUnaryOperator;
readonly operand: UnaryExpression;
}
type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;
interface PostfixUnaryExpression extends UpdateExpression {
readonly kind: SyntaxKind.PostfixUnaryExpression;
readonly operand: LeftHandSideExpression;
readonly operator: PostfixUnaryOperator;
}
interface LeftHandSideExpression extends UpdateExpression {
_leftHandSideExpressionBrand: any;
}
interface MemberExpression extends LeftHandSideExpression {
_memberExpressionBrand: any;
}
interface PrimaryExpression extends MemberExpression {
_primaryExpressionBrand: any;
}
interface NullLiteral extends PrimaryExpression {
readonly kind: SyntaxKind.NullKeyword;
}
interface TrueLiteral extends PrimaryExpression {
readonly kind: SyntaxKind.TrueKeyword;
}
interface FalseLiteral extends PrimaryExpression {
readonly kind: SyntaxKind.FalseKeyword;
}
type BooleanLiteral = TrueLiteral | FalseLiteral;
interface ThisExpression extends PrimaryExpression, FlowContainer {
readonly kind: SyntaxKind.ThisKeyword;
}
interface SuperExpression extends PrimaryExpression, FlowContainer {
readonly kind: SyntaxKind.SuperKeyword;
}
interface ImportExpression extends PrimaryExpression {
readonly kind: SyntaxKind.ImportKeyword;
}
interface DeleteExpression extends UnaryExpression {
readonly kind: SyntaxKind.DeleteExpression;
readonly expression: UnaryExpression;
}
interface TypeOfExpression extends UnaryExpression {
readonly kind: SyntaxKind.TypeOfExpression;
readonly expression: UnaryExpression;
}
interface VoidExpression extends UnaryExpression {
readonly kind: SyntaxKind.VoidExpression;
readonly expression: UnaryExpression;
}
interface AwaitExpression extends UnaryExpression {
readonly kind: SyntaxKind.AwaitExpression;
readonly expression: UnaryExpression;
}
interface YieldExpression extends Expression {
readonly kind: SyntaxKind.YieldExpression;
readonly asteriskToken?: AsteriskToken;
readonly expression?: Expression;
}
interface SyntheticExpression extends Expression {
readonly kind: SyntaxKind.SyntheticExpression;
readonly isSpread: boolean;
readonly type: Type;
readonly tupleNameSource?: ParameterDeclaration | NamedTupleMember;
}
type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;
type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;
type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken;
type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator;
type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;
type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InstanceOfKeyword | SyntaxKind.InKeyword;
type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator;
type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken;
type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator;
type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken;
type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator;
type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken;
type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;
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 | SyntaxKind.BarBarEqualsToken | SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.QuestionQuestionEqualsToken;
type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;
type AssignmentOperatorOrHigher = SyntaxKind.QuestionQuestionToken | LogicalOperatorOrHigher | AssignmentOperator;
type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;
type LogicalOrCoalescingAssignmentOperator = SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.QuestionQuestionEqualsToken;
type BinaryOperatorToken = Token;
interface BinaryExpression extends Expression, Declaration, JSDocContainer {
readonly kind: SyntaxKind.BinaryExpression;
readonly left: Expression;
readonly operatorToken: BinaryOperatorToken;
readonly right: Expression;
}
type AssignmentOperatorToken = Token;
interface AssignmentExpression extends BinaryExpression {
readonly left: LeftHandSideExpression;
readonly operatorToken: TOperator;
}
interface ObjectDestructuringAssignment extends AssignmentExpression {
readonly left: ObjectLiteralExpression;
}
interface ArrayDestructuringAssignment extends AssignmentExpression {
readonly left: ArrayLiteralExpression;
}
type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment;
type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | ObjectBindingOrAssignmentElement | ArrayBindingOrAssignmentElement;
type ObjectBindingOrAssignmentElement = BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment;
type ArrayBindingOrAssignmentElement = BindingElement | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression | Identifier | PropertyAccessExpression | ElementAccessExpression;
type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment;
type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Identifier | PropertyAccessExpression | ElementAccessExpression | OmittedExpression;
type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression;
type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression;
type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression;
type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern;
interface ConditionalExpression extends Expression {
readonly kind: SyntaxKind.ConditionalExpression;
readonly condition: Expression;
readonly questionToken: QuestionToken;
readonly whenTrue: Expression;
readonly colonToken: ColonToken;
readonly whenFalse: Expression;
}
type FunctionBody = Block;
type ConciseBody = FunctionBody | Expression;
interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.FunctionExpression;
readonly modifiers?: NodeArray;
readonly name?: Identifier;
readonly body: FunctionBody;
}
interface ArrowFunction extends Expression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.ArrowFunction;
readonly modifiers?: NodeArray;
readonly equalsGreaterThanToken: EqualsGreaterThanToken;
readonly body: ConciseBody;
readonly name: never;
}
interface LiteralLikeNode extends Node {
text: string;
isUnterminated?: boolean;
hasExtendedUnicodeEscape?: boolean;
}
interface TemplateLiteralLikeNode extends LiteralLikeNode {
rawText?: string;
}
interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
_literalExpressionBrand: any;
}
interface RegularExpressionLiteral extends LiteralExpression {
readonly kind: SyntaxKind.RegularExpressionLiteral;
}
interface NoSubstitutionTemplateLiteral extends LiteralExpression, TemplateLiteralLikeNode, Declaration {
readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
}
enum TokenFlags {
None = 0,
Scientific = 16,
Octal = 32,
HexSpecifier = 64,
BinarySpecifier = 128,
OctalSpecifier = 256,
}
interface NumericLiteral extends LiteralExpression, Declaration {
readonly kind: SyntaxKind.NumericLiteral;
}
interface BigIntLiteral extends LiteralExpression {
readonly kind: SyntaxKind.BigIntLiteral;
}
type LiteralToken = NumericLiteral | BigIntLiteral | StringLiteral | JsxText | RegularExpressionLiteral | NoSubstitutionTemplateLiteral;
interface TemplateHead extends TemplateLiteralLikeNode {
readonly kind: SyntaxKind.TemplateHead;
readonly parent: TemplateExpression | TemplateLiteralTypeNode;
}
interface TemplateMiddle extends TemplateLiteralLikeNode {
readonly kind: SyntaxKind.TemplateMiddle;
readonly parent: TemplateSpan | TemplateLiteralTypeSpan;
}
interface TemplateTail extends TemplateLiteralLikeNode {
readonly kind: SyntaxKind.TemplateTail;
readonly parent: TemplateSpan | TemplateLiteralTypeSpan;
}
type PseudoLiteralToken = TemplateHead | TemplateMiddle | TemplateTail;
type TemplateLiteralToken = NoSubstitutionTemplateLiteral | PseudoLiteralToken;
interface TemplateExpression extends PrimaryExpression {
readonly kind: SyntaxKind.TemplateExpression;
readonly head: TemplateHead;
readonly templateSpans: NodeArray;
}
type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;
interface TemplateSpan extends Node {
readonly kind: SyntaxKind.TemplateSpan;
readonly parent: TemplateExpression;
readonly expression: Expression;
readonly literal: TemplateMiddle | TemplateTail;
}
interface ParenthesizedExpression extends PrimaryExpression, JSDocContainer {
readonly kind: SyntaxKind.ParenthesizedExpression;
readonly expression: Expression;
}
interface ArrayLiteralExpression extends PrimaryExpression {
readonly kind: SyntaxKind.ArrayLiteralExpression;
readonly elements: NodeArray;
}
interface SpreadElement extends Expression {
readonly kind: SyntaxKind.SpreadElement;
readonly parent: ArrayLiteralExpression | CallExpression | NewExpression;
readonly 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.)
*/
interface ObjectLiteralExpressionBase extends PrimaryExpression, Declaration {
readonly properties: NodeArray;
}
interface ObjectLiteralExpression extends ObjectLiteralExpressionBase, JSDocContainer {
readonly kind: SyntaxKind.ObjectLiteralExpression;
}
type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
type AccessExpression = PropertyAccessExpression | ElementAccessExpression;
interface PropertyAccessExpression extends MemberExpression, NamedDeclaration, JSDocContainer, FlowContainer {
readonly kind: SyntaxKind.PropertyAccessExpression;
readonly expression: LeftHandSideExpression;
readonly questionDotToken?: QuestionDotToken;
readonly name: MemberName;
}
interface PropertyAccessChain extends PropertyAccessExpression {
_optionalChainBrand: any;
readonly name: MemberName;
}
interface SuperPropertyAccessExpression extends PropertyAccessExpression {
readonly expression: SuperExpression;
}
/** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
_propertyAccessExpressionLikeQualifiedNameBrand?: any;
readonly expression: EntityNameExpression;
readonly name: Identifier;
}
interface ElementAccessExpression extends MemberExpression, Declaration, JSDocContainer, FlowContainer {
readonly kind: SyntaxKind.ElementAccessExpression;
readonly expression: LeftHandSideExpression;
readonly questionDotToken?: QuestionDotToken;
readonly argumentExpression: Expression;
}
interface ElementAccessChain extends ElementAccessExpression {
_optionalChainBrand: any;
}
interface SuperElementAccessExpression extends ElementAccessExpression {
readonly expression: SuperExpression;
}
type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression;
interface CallExpression extends LeftHandSideExpression, Declaration {
readonly kind: SyntaxKind.CallExpression;
readonly expression: LeftHandSideExpression;
readonly questionDotToken?: QuestionDotToken;
readonly typeArguments?: NodeArray;
readonly arguments: NodeArray;
}
interface CallChain extends CallExpression {
_optionalChainBrand: any;
}
type OptionalChain = PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain;
interface SuperCall extends CallExpression {
readonly expression: SuperExpression;
}
interface ImportCall extends CallExpression {
readonly expression: ImportExpression | ImportDeferProperty;
}
interface ExpressionWithTypeArguments extends MemberExpression, NodeWithTypeArguments {
readonly kind: SyntaxKind.ExpressionWithTypeArguments;
readonly expression: LeftHandSideExpression;
}
interface NewExpression extends PrimaryExpression, Declaration {
readonly kind: SyntaxKind.NewExpression;
readonly expression: LeftHandSideExpression;
readonly typeArguments?: NodeArray;
readonly arguments?: NodeArray;
}
interface TaggedTemplateExpression extends MemberExpression {
readonly kind: SyntaxKind.TaggedTemplateExpression;
readonly tag: LeftHandSideExpression;
readonly typeArguments?: NodeArray;
readonly template: TemplateLiteral;
}
interface InstanceofExpression extends BinaryExpression {
readonly operatorToken: Token;
}
type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxCallLike | InstanceofExpression;
interface AsExpression extends Expression {
readonly kind: SyntaxKind.AsExpression;
readonly expression: Expression;
readonly type: TypeNode;
}
interface TypeAssertion extends UnaryExpression {
readonly kind: SyntaxKind.TypeAssertionExpression;
readonly type: TypeNode;
readonly expression: UnaryExpression;
}
interface SatisfiesExpression extends Expression {
readonly kind: SyntaxKind.SatisfiesExpression;
readonly expression: Expression;
readonly type: TypeNode;
}
type AssertionExpression = TypeAssertion | AsExpression;
interface NonNullExpression extends LeftHandSideExpression {
readonly kind: SyntaxKind.NonNullExpression;
readonly expression: Expression;
}
interface NonNullChain extends NonNullExpression {
_optionalChainBrand: any;
}
interface MetaProperty extends PrimaryExpression, FlowContainer {
readonly kind: SyntaxKind.MetaProperty;
readonly keywordToken: SyntaxKind.NewKeyword | SyntaxKind.ImportKeyword;
readonly name: Identifier;
}
interface ImportDeferProperty extends MetaProperty {
readonly keywordToken: SyntaxKind.ImportKeyword;
readonly name: Identifier & {
readonly escapedText: __String & "defer";
};
}
interface JsxElement extends PrimaryExpression {
readonly kind: SyntaxKind.JsxElement;
readonly openingElement: JsxOpeningElement;
readonly children: NodeArray;
readonly closingElement: JsxClosingElement;
}
type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
type JsxCallLike = JsxOpeningLikeElement | JsxOpeningFragment;
type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
type JsxAttributeName = Identifier | JsxNamespacedName;
type JsxTagNameExpression = Identifier | ThisExpression | JsxTagNamePropertyAccess | JsxNamespacedName;
interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
readonly expression: Identifier | ThisExpression | JsxTagNamePropertyAccess;
}
interface JsxAttributes extends PrimaryExpression, Declaration {
readonly properties: NodeArray;
readonly kind: SyntaxKind.JsxAttributes;
readonly parent: JsxOpeningLikeElement;
}
interface JsxNamespacedName extends Node {
readonly kind: SyntaxKind.JsxNamespacedName;
readonly name: Identifier;
readonly namespace: Identifier;
}
interface JsxOpeningElement extends Expression {
readonly kind: SyntaxKind.JsxOpeningElement;
readonly parent: JsxElement;
readonly tagName: JsxTagNameExpression;
readonly typeArguments?: NodeArray;
readonly attributes: JsxAttributes;
}
interface JsxSelfClosingElement extends PrimaryExpression {
readonly kind: SyntaxKind.JsxSelfClosingElement;
readonly tagName: JsxTagNameExpression;
readonly typeArguments?: NodeArray;
readonly attributes: JsxAttributes;
}
interface JsxFragment extends PrimaryExpression {
readonly kind: SyntaxKind.JsxFragment;
readonly openingFragment: JsxOpeningFragment;
readonly children: NodeArray;
readonly closingFragment: JsxClosingFragment;
}
interface JsxOpeningFragment extends Expression {
readonly kind: SyntaxKind.JsxOpeningFragment;
readonly parent: JsxFragment;
}
interface JsxClosingFragment extends Expression {
readonly kind: SyntaxKind.JsxClosingFragment;
readonly parent: JsxFragment;
}
interface JsxAttribute extends Declaration {
readonly kind: SyntaxKind.JsxAttribute;
readonly parent: JsxAttributes;
readonly name: JsxAttributeName;
readonly initializer?: JsxAttributeValue;
}
type JsxAttributeValue = StringLiteral | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
interface JsxSpreadAttribute extends ObjectLiteralElement {
readonly kind: SyntaxKind.JsxSpreadAttribute;
readonly parent: JsxAttributes;
readonly expression: Expression;
}
interface JsxClosingElement extends Node {
readonly kind: SyntaxKind.JsxClosingElement;
readonly parent: JsxElement;
readonly tagName: JsxTagNameExpression;
}
interface JsxExpression extends Expression {
readonly kind: SyntaxKind.JsxExpression;
readonly parent: JsxElement | JsxFragment | JsxAttributeLike;
readonly dotDotDotToken?: Token;
readonly expression?: Expression;
}
interface JsxText extends LiteralLikeNode {
readonly kind: SyntaxKind.JsxText;
readonly parent: JsxElement | JsxFragment;
readonly containsOnlyTriviaWhiteSpaces: boolean;
}
type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
interface Statement extends Node, JSDocContainer {
_statementBrand: any;
}
interface NotEmittedStatement extends Statement {
readonly kind: SyntaxKind.NotEmittedStatement;
}
interface NotEmittedTypeElement extends TypeElement {
readonly kind: SyntaxKind.NotEmittedTypeElement;
}
/**
* A list of comma-separated expressions. This node is only created by transformations.
*/
interface CommaListExpression extends Expression {
readonly kind: SyntaxKind.CommaListExpression;
readonly elements: NodeArray;
}
interface EmptyStatement extends Statement {
readonly kind: SyntaxKind.EmptyStatement;
}
interface DebuggerStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.DebuggerStatement;
}
interface MissingDeclaration extends DeclarationStatement, PrimaryExpression {
readonly kind: SyntaxKind.MissingDeclaration;
readonly name?: Identifier;
}
type BlockLike = SourceFile | Block | ModuleBlock | CaseOrDefaultClause;
interface Block extends Statement, LocalsContainer {
readonly kind: SyntaxKind.Block;
readonly statements: NodeArray;
}
interface VariableStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.VariableStatement;
readonly modifiers?: NodeArray;
readonly declarationList: VariableDeclarationList;
}
interface ExpressionStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.ExpressionStatement;
readonly expression: Expression;
}
interface IfStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.IfStatement;
readonly expression: Expression;
readonly thenStatement: Statement;
readonly elseStatement?: Statement;
}
interface IterationStatement extends Statement {
readonly statement: Statement;
}
interface DoStatement extends IterationStatement, FlowContainer {
readonly kind: SyntaxKind.DoStatement;
readonly expression: Expression;
}
interface WhileStatement extends IterationStatement, FlowContainer {
readonly kind: SyntaxKind.WhileStatement;
readonly expression: Expression;
}
type ForInitializer = VariableDeclarationList | Expression;
interface ForStatement extends IterationStatement, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.ForStatement;
readonly initializer?: ForInitializer;
readonly condition?: Expression;
readonly incrementor?: Expression;
}
type ForInOrOfStatement = ForInStatement | ForOfStatement;
interface ForInStatement extends IterationStatement, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.ForInStatement;
readonly initializer: ForInitializer;
readonly expression: Expression;
}
interface ForOfStatement extends IterationStatement, LocalsContainer, FlowContainer {
readonly kind: SyntaxKind.ForOfStatement;
readonly awaitModifier?: AwaitKeyword;
readonly initializer: ForInitializer;
readonly expression: Expression;
}
interface BreakStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.BreakStatement;
readonly label?: Identifier;
}
interface ContinueStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.ContinueStatement;
readonly label?: Identifier;
}
type BreakOrContinueStatement = BreakStatement | ContinueStatement;
interface ReturnStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.ReturnStatement;
readonly expression?: Expression;
}
interface WithStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.WithStatement;
readonly expression: Expression;
readonly statement: Statement;
}
interface SwitchStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.SwitchStatement;
readonly expression: Expression;
readonly caseBlock: CaseBlock;
possiblyExhaustive?: boolean;
}
interface CaseBlock extends Node, LocalsContainer {
readonly kind: SyntaxKind.CaseBlock;
readonly parent: SwitchStatement;
readonly clauses: NodeArray;
}
interface CaseClause extends Node, JSDocContainer {
readonly kind: SyntaxKind.CaseClause;
readonly parent: CaseBlock;
readonly expression: Expression;
readonly statements: NodeArray;
}
interface DefaultClause extends Node {
readonly kind: SyntaxKind.DefaultClause;
readonly parent: CaseBlock;
readonly statements: NodeArray;
}
type CaseOrDefaultClause = CaseClause | DefaultClause;
interface LabeledStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.LabeledStatement;
readonly label: Identifier;
readonly statement: Statement;
}
interface ThrowStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.ThrowStatement;
readonly expression: Expression;
}
interface TryStatement extends Statement, FlowContainer {
readonly kind: SyntaxKind.TryStatement;
readonly tryBlock: Block;
readonly catchClause?: CatchClause;
readonly finallyBlock?: Block;
}
interface CatchClause extends Node, LocalsContainer {
readonly kind: SyntaxKind.CatchClause;
readonly parent: TryStatement;
readonly variableDeclaration?: VariableDeclaration;
readonly block: Block;
}
type ObjectTypeDeclaration = ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode;
type DeclarationWithTypeParameters = DeclarationWithTypeParameterChildren | JSDocTypedefTag | JSDocCallbackTag | JSDocSignature;
type DeclarationWithTypeParameterChildren = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTemplateTag;
interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression;
readonly name?: Identifier;
readonly typeParameters?: NodeArray;
readonly heritageClauses?: NodeArray;
readonly members: NodeArray;
}
interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
readonly kind: SyntaxKind.ClassDeclaration;
readonly modifiers?: NodeArray;
/** May be undefined in `export default class { ... }`. */
readonly name?: Identifier;
}
interface ClassExpression extends ClassLikeDeclarationBase, PrimaryExpression {
readonly kind: SyntaxKind.ClassExpression;
readonly modifiers?: NodeArray;
}
type ClassLikeDeclaration = ClassDeclaration | ClassExpression;
interface ClassElement extends NamedDeclaration {
_classElementBrand: any;
readonly name?: PropertyName;
}
interface TypeElement extends NamedDeclaration {
_typeElementBrand: any;
readonly name?: PropertyName;
readonly questionToken?: QuestionToken | undefined;
}
interface InterfaceDeclaration extends DeclarationStatement, JSDocContainer {
readonly kind: SyntaxKind.InterfaceDeclaration;
readonly modifiers?: NodeArray;
readonly name: Identifier;
readonly typeParameters?: NodeArray;
readonly heritageClauses?: NodeArray;
readonly members: NodeArray;
}
interface HeritageClause extends Node {
readonly kind: SyntaxKind.HeritageClause;
readonly parent: InterfaceDeclaration | ClassLikeDeclaration;
readonly token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword;
readonly types: NodeArray;
}
interface TypeAliasDeclaration extends DeclarationStatement, JSDocContainer, LocalsContainer {
readonly kind: SyntaxKind.TypeAliasDeclaration;
readonly modifiers?: NodeArray;
readonly name: Identifier;
readonly typeParameters?: NodeArray;
readonly type: TypeNode;
}
interface EnumMember extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.EnumMember;
readonly parent: EnumDeclaration;
readonly name: PropertyName;
readonly initializer?: Expression;
}
interface EnumDeclaration extends DeclarationStatement, JSDocContainer {
readonly kind: SyntaxKind.EnumDeclaration;
readonly modifiers?: NodeArray;
readonly name: Identifier;
readonly members: NodeArray;
}
type ModuleName = Identifier | StringLiteral;
type ModuleBody = NamespaceBody | JSDocNamespaceBody;
interface ModuleDeclaration extends DeclarationStatement, JSDocContainer, LocalsContainer {
readonly kind: SyntaxKind.ModuleDeclaration;
readonly parent: ModuleBody | SourceFile;
readonly modifiers?: NodeArray;
readonly name: ModuleName;
readonly body?: ModuleBody | JSDocNamespaceDeclaration;
}
type NamespaceBody = ModuleBlock | NamespaceDeclaration;
interface NamespaceDeclaration extends ModuleDeclaration {
readonly name: Identifier;
readonly body: NamespaceBody;
}
type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
interface JSDocNamespaceDeclaration extends ModuleDeclaration {
readonly name: Identifier;
readonly body?: JSDocNamespaceBody;
}
interface ModuleBlock extends Node, Statement {
readonly kind: SyntaxKind.ModuleBlock;
readonly parent: ModuleDeclaration;
readonly statements: NodeArray;
}
type ModuleReference = EntityName | ExternalModuleReference;
/**
* One of:
* - import x = require("mod");
* - import x = M.x;
*/
interface ImportEqualsDeclaration extends DeclarationStatement, JSDocContainer {
readonly kind: SyntaxKind.ImportEqualsDeclaration;
readonly parent: SourceFile | ModuleBlock;
readonly modifiers?: NodeArray;
readonly name: Identifier;
readonly isTypeOnly: boolean;
readonly moduleReference: ModuleReference;
}
interface ExternalModuleReference extends Node {
readonly kind: SyntaxKind.ExternalModuleReference;
readonly parent: ImportEqualsDeclaration;
readonly expression: Expression;
}
interface ImportDeclaration extends Statement {
readonly kind: SyntaxKind.ImportDeclaration;
readonly parent: SourceFile | ModuleBlock;
readonly modifiers?: NodeArray;
readonly importClause?: ImportClause;
/** If this is not a StringLiteral it will be a grammar error. */
readonly moduleSpecifier: Expression;
/** @deprecated */ readonly assertClause?: AssertClause;
readonly attributes?: ImportAttributes;
}
type NamedImportBindings = NamespaceImport | NamedImports;
type NamedExportBindings = NamespaceExport | NamedExports;
interface ImportClause extends NamedDeclaration {
readonly kind: SyntaxKind.ImportClause;
readonly parent: ImportDeclaration | JSDocImportTag;
/** @deprecated Use `phaseModifier` instead */
readonly isTypeOnly: boolean;
readonly phaseModifier: undefined | ImportPhaseModifierSyntaxKind;
readonly name?: Identifier;
readonly namedBindings?: NamedImportBindings;
}
type ImportPhaseModifierSyntaxKind = SyntaxKind.TypeKeyword | SyntaxKind.DeferKeyword;
/** @deprecated */
type AssertionKey = ImportAttributeName;
/** @deprecated */
interface AssertEntry extends ImportAttribute {
}
/** @deprecated */
interface AssertClause extends ImportAttributes {
}
type ImportAttributeName = Identifier | StringLiteral;
interface ImportAttribute extends Node {
readonly kind: SyntaxKind.ImportAttribute;
readonly parent: ImportAttributes;
readonly name: ImportAttributeName;
readonly value: Expression;
}
interface ImportAttributes extends Node {
readonly token: SyntaxKind.WithKeyword | SyntaxKind.AssertKeyword;
readonly kind: SyntaxKind.ImportAttributes;
readonly parent: ImportDeclaration | ExportDeclaration;
readonly elements: NodeArray;
readonly multiLine?: boolean;
}
interface NamespaceImport extends NamedDeclaration {
readonly kind: SyntaxKind.NamespaceImport;
readonly parent: ImportClause;
readonly name: Identifier;
}
interface NamespaceExport extends NamedDeclaration {
readonly kind: SyntaxKind.NamespaceExport;
readonly parent: ExportDeclaration;
readonly name: ModuleExportName;
}
interface NamespaceExportDeclaration extends DeclarationStatement, JSDocContainer {
readonly kind: SyntaxKind.NamespaceExportDeclaration;
readonly name: Identifier;
}
interface ExportDeclaration extends DeclarationStatement, JSDocContainer {
readonly kind: SyntaxKind.ExportDeclaration;
readonly parent: SourceFile | ModuleBlock;
readonly modifiers?: NodeArray;
readonly isTypeOnly: boolean;
/** Will not be assigned in the case of `export * from "foo";` */
readonly exportClause?: NamedExportBindings;
/** If this is not a StringLiteral it will be a grammar error. */
readonly moduleSpecifier?: Expression;
/** @deprecated */ readonly assertClause?: AssertClause;
readonly attributes?: ImportAttributes;
}
interface NamedImports extends Node {
readonly kind: SyntaxKind.NamedImports;
readonly parent: ImportClause;
readonly elements: NodeArray;
}
interface NamedExports extends Node {
readonly kind: SyntaxKind.NamedExports;
readonly parent: ExportDeclaration;
readonly elements: NodeArray;
}
type NamedImportsOrExports = NamedImports | NamedExports;
interface ImportSpecifier extends NamedDeclaration {
readonly kind: SyntaxKind.ImportSpecifier;
readonly parent: NamedImports;
readonly propertyName?: ModuleExportName;
readonly name: Identifier;
readonly isTypeOnly: boolean;
}
interface ExportSpecifier extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.ExportSpecifier;
readonly parent: NamedExports;
readonly isTypeOnly: boolean;
readonly propertyName?: ModuleExportName;
readonly name: ModuleExportName;
}
type ModuleExportName = Identifier | StringLiteral;
type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
type TypeOnlyCompatibleAliasDeclaration = ImportClause | ImportEqualsDeclaration | NamespaceImport | ImportOrExportSpecifier | ExportDeclaration | NamespaceExport;
type TypeOnlyImportDeclaration =
| ImportClause & {
readonly isTypeOnly: true;
readonly name: Identifier;
}
| ImportEqualsDeclaration & {
readonly isTypeOnly: true;
}
| NamespaceImport & {
readonly parent: ImportClause & {
readonly isTypeOnly: true;
};
}
| ImportSpecifier
& ({
readonly isTypeOnly: true;
} | {
readonly parent: NamedImports & {
readonly parent: ImportClause & {
readonly isTypeOnly: true;
};
};
});
type TypeOnlyExportDeclaration =
| ExportSpecifier
& ({
readonly isTypeOnly: true;
} | {
readonly parent: NamedExports & {
readonly parent: ExportDeclaration & {
readonly isTypeOnly: true;
};
};
})
| ExportDeclaration & {
readonly isTypeOnly: true;
readonly moduleSpecifier: Expression;
}
| NamespaceExport & {
readonly parent: ExportDeclaration & {
readonly isTypeOnly: true;
readonly moduleSpecifier: Expression;
};
};
type TypeOnlyAliasDeclaration = TypeOnlyImportDeclaration | TypeOnlyExportDeclaration;
/**
* This is either an `export =` or an `export default` declaration.
* Unless `isExportEquals` is set, this node was parsed as an `export default`.
*/
interface ExportAssignment extends DeclarationStatement, JSDocContainer {
readonly kind: SyntaxKind.ExportAssignment;
readonly parent: SourceFile;
readonly modifiers?: NodeArray;
readonly isExportEquals?: boolean;
readonly expression: Expression;
}
interface FileReference extends TextRange {
fileName: string;
resolutionMode?: ResolutionMode;
preserve?: boolean;
}
interface CheckJsDirective extends TextRange {
enabled: boolean;
}
type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia;
interface CommentRange extends TextRange {
hasTrailingNewLine?: boolean;
kind: CommentKind;
}
interface SynthesizedComment extends CommentRange {
text: string;
pos: -1;
end: -1;
hasLeadingNewline?: boolean;
}
interface JSDocTypeExpression extends TypeNode {
readonly kind: SyntaxKind.JSDocTypeExpression;
readonly type: TypeNode;
}
interface JSDocNameReference extends Node {
readonly kind: SyntaxKind.JSDocNameReference;
readonly name: EntityName | JSDocMemberName;
}
/** Class#method reference in JSDoc */
interface JSDocMemberName extends Node {
readonly kind: SyntaxKind.JSDocMemberName;
readonly left: EntityName | JSDocMemberName;
readonly right: Identifier;
}
interface JSDocType extends TypeNode {
_jsDocTypeBrand: any;
}
interface JSDocAllType extends JSDocType {
readonly kind: SyntaxKind.JSDocAllType;
}
interface JSDocUnknownType extends JSDocType {
readonly kind: SyntaxKind.JSDocUnknownType;
}
interface JSDocNonNullableType extends JSDocType {
readonly kind: SyntaxKind.JSDocNonNullableType;
readonly type: TypeNode;
readonly postfix: boolean;
}
interface JSDocNullableType extends JSDocType {
readonly kind: SyntaxKind.JSDocNullableType;
readonly type: TypeNode;
readonly postfix: boolean;
}
interface JSDocOptionalType extends JSDocType {
readonly kind: SyntaxKind.JSDocOptionalType;
readonly type: TypeNode;
}
interface JSDocFunctionType extends JSDocType, SignatureDeclarationBase, LocalsContainer {
readonly kind: SyntaxKind.JSDocFunctionType;
}
interface JSDocVariadicType extends JSDocType {
readonly kind: SyntaxKind.JSDocVariadicType;
readonly type: TypeNode;
}
interface JSDocNamepathType extends JSDocType {
readonly kind: SyntaxKind.JSDocNamepathType;
readonly type: TypeNode;
}
type JSDocTypeReferencingNode = JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
interface JSDoc extends Node {
readonly kind: SyntaxKind.JSDoc;
readonly parent: HasJSDoc;
readonly tags?: NodeArray;
readonly comment?: string | NodeArray;
}
interface JSDocTag extends Node {
readonly parent: JSDoc | JSDocTypeLiteral;
readonly tagName: Identifier;
readonly comment?: string | NodeArray;
}
interface JSDocLink extends Node {
readonly kind: SyntaxKind.JSDocLink;
readonly name?: EntityName | JSDocMemberName;
text: string;
}
interface JSDocLinkCode extends Node {
readonly kind: SyntaxKind.JSDocLinkCode;
readonly name?: EntityName | JSDocMemberName;
text: string;
}
interface JSDocLinkPlain extends Node {
readonly kind: SyntaxKind.JSDocLinkPlain;
readonly name?: EntityName | JSDocMemberName;
text: string;
}
type JSDocComment = JSDocText | JSDocLink | JSDocLinkCode | JSDocLinkPlain;
interface JSDocText extends Node {
readonly kind: SyntaxKind.JSDocText;
text: string;
}
interface JSDocUnknownTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocTag;
}
/**
* Note that `@extends` is a synonym of `@augments`.
* Both tags are represented by this interface.
*/
interface JSDocAugmentsTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocAugmentsTag;
readonly class: ExpressionWithTypeArguments & {
readonly expression: Identifier | PropertyAccessEntityNameExpression;
};
}
interface JSDocImplementsTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocImplementsTag;
readonly class: ExpressionWithTypeArguments & {
readonly expression: Identifier | PropertyAccessEntityNameExpression;
};
}
interface JSDocAuthorTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocAuthorTag;
}
interface JSDocDeprecatedTag extends JSDocTag {
kind: SyntaxKind.JSDocDeprecatedTag;
}
interface JSDocClassTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocClassTag;
}
interface JSDocPublicTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocPublicTag;
}
interface JSDocPrivateTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocPrivateTag;
}
interface JSDocProtectedTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocProtectedTag;
}
interface JSDocReadonlyTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocReadonlyTag;
}
interface JSDocOverrideTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocOverrideTag;
}
interface JSDocEnumTag extends JSDocTag, Declaration, LocalsContainer {
readonly kind: SyntaxKind.JSDocEnumTag;
readonly parent: JSDoc;
readonly typeExpression: JSDocTypeExpression;
}
interface JSDocThisTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocThisTag;
readonly typeExpression: JSDocTypeExpression;
}
interface JSDocTemplateTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocTemplateTag;
readonly constraint: JSDocTypeExpression | undefined;
readonly typeParameters: NodeArray;
}
interface JSDocSeeTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocSeeTag;
readonly name?: JSDocNameReference;
}
interface JSDocReturnTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocReturnTag;
readonly typeExpression?: JSDocTypeExpression;
}
interface JSDocTypeTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocTypeTag;
readonly typeExpression: JSDocTypeExpression;
}
interface JSDocTypedefTag extends JSDocTag, NamedDeclaration, LocalsContainer {
readonly kind: SyntaxKind.JSDocTypedefTag;
readonly parent: JSDoc;
readonly fullName?: JSDocNamespaceDeclaration | Identifier;
readonly name?: Identifier;
readonly typeExpression?: JSDocTypeExpression | JSDocTypeLiteral;
}
interface JSDocCallbackTag extends JSDocTag, NamedDeclaration, LocalsContainer {
readonly kind: SyntaxKind.JSDocCallbackTag;
readonly parent: JSDoc;
readonly fullName?: JSDocNamespaceDeclaration | Identifier;
readonly name?: Identifier;
readonly typeExpression: JSDocSignature;
}
interface JSDocOverloadTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocOverloadTag;
readonly parent: JSDoc;
readonly typeExpression: JSDocSignature;
}
interface JSDocThrowsTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocThrowsTag;
readonly typeExpression?: JSDocTypeExpression;
}
interface JSDocSignature extends JSDocType, Declaration, JSDocContainer, LocalsContainer {
readonly kind: SyntaxKind.JSDocSignature;
readonly typeParameters?: readonly JSDocTemplateTag[];
readonly parameters: readonly JSDocParameterTag[];
readonly type: JSDocReturnTag | undefined;
}
interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
readonly parent: JSDoc;
readonly name: EntityName;
readonly typeExpression?: JSDocTypeExpression;
/** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
readonly isNameFirst: boolean;
readonly isBracketed: boolean;
}
interface JSDocPropertyTag extends JSDocPropertyLikeTag {
readonly kind: SyntaxKind.JSDocPropertyTag;
}
interface JSDocParameterTag extends JSDocPropertyLikeTag {
readonly kind: SyntaxKind.JSDocParameterTag;
}
interface JSDocTypeLiteral extends JSDocType, Declaration {
readonly kind: SyntaxKind.JSDocTypeLiteral;
readonly jsDocPropertyTags?: readonly JSDocPropertyLikeTag[];
/** If true, then this type literal represents an *array* of its type. */
readonly isArrayType: boolean;
}
interface JSDocSatisfiesTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocSatisfiesTag;
readonly typeExpression: JSDocTypeExpression;
}
interface JSDocImportTag extends JSDocTag {
readonly kind: SyntaxKind.JSDocImportTag;
readonly parent: JSDoc;
readonly importClause?: ImportClause;
readonly moduleSpecifier: Expression;
readonly attributes?: ImportAttributes;
}
type FlowType = Type | IncompleteType;
interface IncompleteType {
flags: TypeFlags | 0;
type: Type;
}
interface AmdDependency {
path: string;
name?: string;
}
/**
* Subset of properties from SourceFile that are used in multiple utility functions
*/
interface SourceFileLike {
readonly text: string;
}
interface SourceFileLike {
getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
}
type ResolutionMode = ModuleKind.ESNext | ModuleKind.CommonJS | undefined;
interface SourceFile extends Declaration, LocalsContainer {
readonly kind: SyntaxKind.SourceFile;
readonly statements: NodeArray;
readonly endOfFileToken: Token;
fileName: string;
text: string;
amdDependencies: readonly AmdDependency[];
moduleName?: string;
referencedFiles: readonly FileReference[];
typeReferenceDirectives: readonly FileReference[];
libReferenceDirectives: readonly FileReference[];
languageVariant: LanguageVariant;
isDeclarationFile: boolean;
/**
* lib.d.ts should have a reference comment like
*
* ///
*
* 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;
/**
* When `module` is `Node16` or `NodeNext`, this field controls whether the
* source file in question is an ESNext-output-format file, or a CommonJS-output-format
* module. This is derived by the module resolver as it looks up the file, since
* it is derived from either the file extension of the module, or the containing
* `package.json` context, and affects both checking and emit.
*
* It is _public_ so that (pre)transformers can set this field,
* since it switches the builtin `node` module transform. Generally speaking, if unset,
* the field is treated as though it is `ModuleKind.CommonJS`.
*
* Note that this field is only set by the module resolution process when
* `moduleResolution` is `Node16` or `NodeNext`, which is implied by the `module` setting
* of `Node16` or `NodeNext`, respectively, but may be overriden (eg, by a `moduleResolution`
* of `node`). If so, this field will be unset and source files will be considered to be
* CommonJS-output-format by the node module transformer and type checker, regardless of extension or context.
*/
impliedNodeFormat?: ResolutionMode;
}
interface SourceFile {
getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
getLineEndOfPosition(pos: number): number;
getLineStarts(): readonly number[];
getPositionOfLineAndCharacter(line: number, character: number): number;
update(newText: string, textChangeRange: TextChangeRange): SourceFile;
}
interface Bundle extends Node {
readonly kind: SyntaxKind.Bundle;
readonly sourceFiles: readonly SourceFile[];
}
interface JsonSourceFile extends SourceFile {
readonly statements: NodeArray;
}
interface TsConfigSourceFile extends JsonSourceFile {
extendedSourceFiles?: string[];
}
interface JsonMinusNumericLiteral extends PrefixUnaryExpression {
readonly kind: SyntaxKind.PrefixUnaryExpression;
readonly operator: SyntaxKind.MinusToken;
readonly operand: NumericLiteral;
}
type JsonObjectExpression = ObjectLiteralExpression | ArrayLiteralExpression | JsonMinusNumericLiteral | NumericLiteral | StringLiteral | BooleanLiteral | NullLiteral;
interface JsonObjectExpressionStatement extends ExpressionStatement {
readonly expression: JsonObjectExpression;
}
interface ScriptReferenceHost {
getCompilerOptions(): CompilerOptions;
getSourceFile(fileName: string): SourceFile | undefined;
getSourceFileByPath(path: Path): SourceFile | undefined;
getCurrentDirectory(): string;
}
interface ParseConfigHost extends ModuleResolutionHost {
useCaseSensitiveFileNames: boolean;
readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): readonly string[];
/**
* Gets a value indicating whether the specified path exists and is a file.
* @param path The path to test.
*/
fileExists(path: string): boolean;
readFile(path: string): string | undefined;
trace?(s: string): void;
}
/**
* Branded string for keeping track of when we've turned an ambiguous path
* specified like "./blah" to an absolute path to an actual
* tsconfig file, e.g. "/root/blah/tsconfig.json"
*/
type ResolvedConfigFileName = string & {
_isResolvedConfigFileName: never;
};
interface WriteFileCallbackData {
}
type WriteFileCallback = (fileName: string, text: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: readonly SourceFile[], data?: WriteFileCallbackData) => void;
class OperationCanceledException {
}
interface CancellationToken {
isCancellationRequested(): boolean;
/** @throws OperationCanceledException if isCancellationRequested is true */
throwIfCancellationRequested(): void;
}
interface Program extends ScriptReferenceHost {
getCurrentDirectory(): string;
/**
* Get a list of root file names that were passed to a 'createProgram'
*/
getRootFileNames(): readonly string[];
/**
* Get a list of files in the program
*/
getSourceFiles(): readonly SourceFile[];
/**
* Emits the JavaScript and declaration files. If targetSourceFile is not specified, then
* the JavaScript and declaration files will be produced for all the files in this program.
* If targetSourceFile is specified, then only the JavaScript and declaration for that
* specific file will be generated.
*
* If writeFile is not specified then the writeFile callback from the compiler host will be
* used for writing the JavaScript and declaration files. Otherwise, the writeFile parameter
* will be invoked when writing the JavaScript and declaration files.
*/
emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
/** The first time this is called, it will return global diagnostics (no location). */
getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
getConfigFileParsingDiagnostics(): readonly Diagnostic[];
/**
* Gets a type checker that can be used to semantically analyze source files in the program.
*/
getTypeChecker(): TypeChecker;
getNodeCount(): number;
getIdentifierCount(): number;
getSymbolCount(): number;
getTypeCount(): number;
getInstantiationCount(): number;
getRelationCacheSizes(): {
assignable: number;
identity: number;
subtype: number;
strictSubtype: number;
};
isSourceFileFromExternalLibrary(file: SourceFile): boolean;
isSourceFileDefaultLibrary(file: SourceFile): boolean;
/**
* Calculates the final resolution mode for a given module reference node. This function only returns a result when module resolution
* settings allow differing resolution between ESM imports and CJS requires, or when a mode is explicitly provided via import attributes,
* which cause an `import` or `require` condition to be used during resolution regardless of module resolution settings. In absence of
* overriding attributes, and in modes that support differing resolution, the result indicates the syntax the usage would emit to JavaScript.
* Some examples:
*
* ```ts
* // tsc foo.mts --module nodenext
* import {} from "mod";
* // Result: ESNext - the import emits as ESM due to `impliedNodeFormat` set by .mts file extension
*
* // tsc foo.cts --module nodenext
* import {} from "mod";
* // Result: CommonJS - the import emits as CJS due to `impliedNodeFormat` set by .cts file extension
*
* // tsc foo.ts --module preserve --moduleResolution bundler
* import {} from "mod";
* // Result: ESNext - the import emits as ESM due to `--module preserve` and `--moduleResolution bundler`
* // supports conditional imports/exports
*
* // tsc foo.ts --module preserve --moduleResolution node10
* import {} from "mod";
* // Result: undefined - the import emits as ESM due to `--module preserve`, but `--moduleResolution node10`
* // does not support conditional imports/exports
*
* // tsc foo.ts --module commonjs --moduleResolution node10
* import type {} from "mod" with { "resolution-mode": "import" };
* // Result: ESNext - conditional imports/exports always supported with "resolution-mode" attribute
* ```
*/
getModeForUsageLocation(file: SourceFile, usage: StringLiteralLike): ResolutionMode;
/**
* Calculates the final resolution mode for an import at some index within a file's `imports` list. This function only returns a result
* when module resolution settings allow differing resolution between ESM imports and CJS requires, or when a mode is explicitly provided
* via import attributes, which cause an `import` or `require` condition to be used during resolution regardless of module resolution
* settings. In absence of overriding attributes, and in modes that support differing resolution, the result indicates the syntax the
* usage would emit to JavaScript. Some examples:
*
* ```ts
* // tsc foo.mts --module nodenext
* import {} from "mod";
* // Result: ESNext - the import emits as ESM due to `impliedNodeFormat` set by .mts file extension
*
* // tsc foo.cts --module nodenext
* import {} from "mod";
* // Result: CommonJS - the import emits as CJS due to `impliedNodeFormat` set by .cts file extension
*
* // tsc foo.ts --module preserve --moduleResolution bundler
* import {} from "mod";
* // Result: ESNext - the import emits as ESM due to `--module preserve` and `--moduleResolution bundler`
* // supports conditional imports/exports
*
* // tsc foo.ts --module preserve --moduleResolution node10
* import {} from "mod";
* // Result: undefined - the import emits as ESM due to `--module preserve`, but `--moduleResolution node10`
* // does not support conditional imports/exports
*
* // tsc foo.ts --module commonjs --moduleResolution node10
* import type {} from "mod" with { "resolution-mode": "import" };
* // Result: ESNext - conditional imports/exports always supported with "resolution-mode" attribute
* ```
*/
getModeForResolutionAtIndex(file: SourceFile, index: number): ResolutionMode;
getProjectReferences(): readonly ProjectReference[] | undefined;
getResolvedProjectReferences(): readonly (ResolvedProjectReference | undefined)[] | undefined;
}
interface ResolvedProjectReference {
commandLine: ParsedCommandLine;
sourceFile: SourceFile;
references?: readonly (ResolvedProjectReference | undefined)[];
}
type CustomTransformerFactory = (context: TransformationContext) => CustomTransformer;
interface CustomTransformer {
transformSourceFile(node: SourceFile): SourceFile;
transformBundle(node: Bundle): Bundle;
}
interface CustomTransformers {
/** Custom transformers to evaluate before built-in .js transformations. */
before?: (TransformerFactory | CustomTransformerFactory)[];
/** Custom transformers to evaluate after built-in .js transformations. */
after?: (TransformerFactory | CustomTransformerFactory)[];
/** Custom transformers to evaluate after built-in .d.ts transformations. */
afterDeclarations?: (TransformerFactory | CustomTransformerFactory)[];
}
interface SourceMapSpan {
/** Line number in the .js file. */
emittedLine: number;
/** Column number in the .js file. */
emittedColumn: number;
/** Line number in the .ts file. */
sourceLine: number;
/** Column number in the .ts file. */
sourceColumn: number;
/** Optional name (index into names array) associated with this span. */
nameIndex?: number;
/** .ts file (index into sources array) associated with this span */
sourceIndex: number;
}
/** Return code used by getEmitOutput function to indicate status of the function */
enum ExitStatus {
Success = 0,
DiagnosticsPresent_OutputsSkipped = 1,
DiagnosticsPresent_OutputsGenerated = 2,
InvalidProject_OutputsSkipped = 3,
ProjectReferenceCycle_OutputsSkipped = 4,
}
interface EmitResult {
emitSkipped: boolean;
/** Contains declaration emit diagnostics */
diagnostics: readonly Diagnostic[];
emittedFiles?: string[];
}
interface TypeChecker {
getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
getTypeOfSymbol(symbol: Symbol): Type;
getDeclaredTypeOfSymbol(symbol: Symbol): Type;
getPropertiesOfType(type: Type): Symbol[];
getPropertyOfType(type: Type, propertyName: string): Symbol | undefined;
getPrivateIdentifierPropertyOfType(leftType: Type, name: string, location: Node): Symbol | undefined;
getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined;
getIndexInfosOfType(type: Type): readonly IndexInfo[];
getIndexInfosOfIndexSymbol: (indexSymbol: Symbol, siblingSymbols?: Symbol[] | undefined) => IndexInfo[];
getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[];
getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined;
getBaseTypes(type: InterfaceType): BaseType[];
getBaseTypeOfLiteralType(type: Type): Type;
getWidenedType(type: Type): Type;
/**
* Gets the "awaited type" of a type.
*
* If an expression has a Promise-like type, the "awaited type" of the expression is
* derived from the type of the first argument of the fulfillment callback for that
* Promise's `then` method. If the "awaited type" is itself a Promise-like, it is
* recursively unwrapped in the same manner until a non-promise type is found.
*
* If an expression does not have a Promise-like type, its "awaited type" is the type
* of the expression.
*
* If the resulting "awaited type" is a generic object type, then it is wrapped in
* an `Awaited`.
*
* In the event the "awaited type" circularly references itself, or is a non-Promise
* object-type with a callable `then()` method, an "awaited type" cannot be determined
* and the value `undefined` will be returned.
*
* This is used to reflect the runtime behavior of the `await` keyword.
*/
getAwaitedType(type: Type): Type | undefined;
getReturnTypeOfSignature(signature: Signature): Type;
getNullableType(type: Type, flags: TypeFlags): Type;
getNonNullableType(type: Type): Type;
getTypeArguments(type: TypeReference): readonly Type[];
/** Note that the resulting nodes cannot be checked. */
typeToTypeNode(type: Type, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeNode | undefined;
/** Note that the resulting nodes cannot be checked. */
signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined):
| SignatureDeclaration & {
typeArguments?: NodeArray;
}
| undefined;
/** Note that the resulting nodes cannot be checked. */
indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): IndexSignatureDeclaration | undefined;
/** Note that the resulting nodes cannot be checked. */
symbolToEntityName(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): EntityName | undefined;
/** Note that the resulting nodes cannot be checked. */
symbolToExpression(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): Expression | undefined;
/** Note that the resulting nodes cannot be checked. */
symbolToTypeParameterDeclarations(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): NodeArray | undefined;
/** Note that the resulting nodes cannot be checked. */
symbolToParameterDeclaration(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): ParameterDeclaration | undefined;
/** Note that the resulting nodes cannot be checked. */
typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeParameterDeclaration | undefined;
getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
getSymbolAtLocation(node: Node): Symbol | undefined;
getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
/**
* The function returns the value (local variable) symbol of an identifier in the short-hand property assignment.
* This is necessary as an identifier in short-hand property assignment can contains two meaning: property name and property value.
*/
getShorthandAssignmentValueSymbol(location: Node | undefined): Symbol | undefined;
getExportSpecifierLocalTargetSymbol(location: ExportSpecifier | Identifier): Symbol | undefined;
/**
* If a symbol is a local symbol with an associated exported symbol, returns the exported symbol.
* Otherwise returns its input.
* For example, at `export type T = number;`:
* - `getSymbolAtLocation` at the location `T` will return the exported symbol for `T`.
* - But the result of `getSymbolsInScope` will contain the *local* symbol for `T`, not the exported symbol.
* - Calling `getExportSymbolOfSymbol` on that local symbol will return the exported symbol.
*/
getExportSymbolOfSymbol(symbol: Symbol): Symbol;
getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol | undefined;
getTypeOfAssignmentPattern(pattern: AssignmentPattern): Type;
getTypeAtLocation(node: Node): Type;
getTypeFromTypeNode(node: TypeNode): Type;
signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): string;
typePredicateToString(predicate: TypePredicate, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
getFullyQualifiedName(symbol: Symbol): string;
getAugmentedPropertiesOfType(type: Type): Symbol[];
getRootSymbols(symbol: Symbol): readonly Symbol[];
getSymbolOfExpando(node: Node, allowDeclaration: boolean): Symbol | undefined;
getContextualType(node: Expression): Type | undefined;
/**
* returns unknownSignature in the case of an error.
* returns undefined if the node is not valid.
* @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`.
*/
getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined;
isImplementationOfOverload(node: SignatureDeclaration): boolean | undefined;
isUndefinedSymbol(symbol: Symbol): boolean;
isArgumentsSymbol(symbol: Symbol): boolean;
isUnknownSymbol(symbol: Symbol): boolean;
getMergedSymbol(symbol: Symbol): Symbol;
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): string | number | undefined;
isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName | ImportTypeNode, propertyName: string): boolean;
/** Follow all aliases to get the original symbol. */
getAliasedSymbol(symbol: Symbol): Symbol;
/** Follow a *single* alias to get the immediately aliased symbol. */
getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined;
getExportsOfModule(moduleSymbol: Symbol): Symbol[];
getJsxIntrinsicTagNamesAt(location: Node): Symbol[];
isOptionalParameter(node: ParameterDeclaration): boolean;
getAmbientModules(): Symbol[];
tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
getApparentType(type: Type): Type;
getBaseConstraintOfType(type: Type): Type | undefined;
getDefaultFromTypeParameter(type: Type): Type | undefined;
/**
* Gets the intrinsic `any` type. There are multiple types that act as `any` used internally in the compiler,
* so the type returned by this function should not be used in equality checks to determine if another type
* is `any`. Instead, use `type.flags & TypeFlags.Any`.
*/
getAnyType(): Type;
getStringType(): Type;
getStringLiteralType(value: string): StringLiteralType;
getNumberType(): Type;
getNumberLiteralType(value: number): NumberLiteralType;
getBigIntType(): Type;
getBigIntLiteralType(value: PseudoBigInt): BigIntLiteralType;
getBooleanType(): Type;
getUnknownType(): Type;
getFalseType(): Type;
getTrueType(): Type;
getVoidType(): Type;
/**
* Gets the intrinsic `undefined` type. There are multiple types that act as `undefined` used internally in the compiler
* depending on compiler options, so the type returned by this function should not be used in equality checks to determine
* if another type is `undefined`. Instead, use `type.flags & TypeFlags.Undefined`.
*/
getUndefinedType(): Type;
/**
* Gets the intrinsic `null` type. There are multiple types that act as `null` used internally in the compiler,
* so the type returned by this function should not be used in equality checks to determine if another type
* is `null`. Instead, use `type.flags & TypeFlags.Null`.
*/
getNullType(): Type;
getESSymbolType(): Type;
/**
* Gets the intrinsic `never` type. There are multiple types that act as `never` used internally in the compiler,
* so the type returned by this function should not be used in equality checks to determine if another type
* is `never`. Instead, use `type.flags & TypeFlags.Never`.
*/
getNeverType(): Type;
/**
* Gets the intrinsic `object` type.
*/
getNonPrimitiveType(): Type;
/**
* Returns true if the "source" type is assignable to the "target" type.
*
* ```ts
* declare const abcLiteral: ts.Type; // Type of "abc"
* declare const stringType: ts.Type; // Type of string
*
* isTypeAssignableTo(abcLiteral, abcLiteral); // true; "abc" is assignable to "abc"
* isTypeAssignableTo(abcLiteral, stringType); // true; "abc" is assignable to string
* isTypeAssignableTo(stringType, abcLiteral); // false; string is not assignable to "abc"
* isTypeAssignableTo(stringType, stringType); // true; string is assignable to string
* ```
*/
isTypeAssignableTo(source: Type, target: Type): boolean;
/**
* True if this type is the `Array` or `ReadonlyArray` type from lib.d.ts.
* This function will _not_ return true if passed a type which
* extends `Array` (for example, the TypeScript AST's `NodeArray` type).
*/
isArrayType(type: Type): boolean;
/**
* True if this type is a tuple type. This function will _not_ return true if
* passed a type which extends from a tuple.
*/
isTupleType(type: Type): boolean;
/**
* True if this type is assignable to `ReadonlyArray`.
*/
isArrayLikeType(type: Type): boolean;
resolveName(name: string, location: Node | undefined, meaning: SymbolFlags, excludeGlobals: boolean): Symbol | undefined;
getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined;
/**
* Depending on the operation performed, it may be appropriate to throw away the checker
* if the cancellation token is triggered. Typically, if it is used for error checking
* and the operation is cancelled, then it should be discarded, otherwise it is safe to keep.
*/
runWithCancellationToken(token: CancellationToken, cb: (checker: TypeChecker) => T): T;
getTypeArgumentsForResolvedSignature(signature: Signature): readonly Type[] | undefined;
}
enum NodeBuilderFlags {
None = 0,
NoTruncation = 1,
WriteArrayAsGenericType = 2,
GenerateNamesForShadowedTypeParams = 4,
UseStructuralFallback = 8,
ForbidIndexedAccessSymbolReferences = 16,
WriteTypeArgumentsOfSignature = 32,
UseFullyQualifiedType = 64,
UseOnlyExternalAliasing = 128,
SuppressAnyReturnType = 256,
WriteTypeParametersInQualifiedName = 512,
MultilineObjectLiterals = 1024,
WriteClassExpressionAsTypeLiteral = 2048,
UseTypeOfFunction = 4096,
OmitParameterModifiers = 8192,
UseAliasDefinedOutsideCurrentScope = 16384,
UseSingleQuotesForStringLiteralType = 268435456,
NoTypeReduction = 536870912,
OmitThisParameter = 33554432,
AllowThisInObjectLiteral = 32768,
AllowQualifiedNameInPlaceOfIdentifier = 65536,
AllowAnonymousIdentifier = 131072,
AllowEmptyUnionOrIntersection = 262144,
AllowEmptyTuple = 524288,
AllowUniqueESSymbolType = 1048576,
AllowEmptyIndexInfoType = 2097152,
AllowNodeModulesRelativePaths = 67108864,
IgnoreErrors = 70221824,
InObjectTypeLiteral = 4194304,
InTypeAlias = 8388608,
InInitialEntityName = 16777216,
}
enum TypeFormatFlags {
None = 0,
NoTruncation = 1,
WriteArrayAsGenericType = 2,
GenerateNamesForShadowedTypeParams = 4,
UseStructuralFallback = 8,
WriteTypeArgumentsOfSignature = 32,
UseFullyQualifiedType = 64,
SuppressAnyReturnType = 256,
MultilineObjectLiterals = 1024,
WriteClassExpressionAsTypeLiteral = 2048,
UseTypeOfFunction = 4096,
OmitParameterModifiers = 8192,
UseAliasDefinedOutsideCurrentScope = 16384,
UseSingleQuotesForStringLiteralType = 268435456,
NoTypeReduction = 536870912,
OmitThisParameter = 33554432,
AllowUniqueESSymbolType = 1048576,
AddUndefined = 131072,
WriteArrowStyleSignature = 262144,
InArrayType = 524288,
InElementType = 2097152,
InFirstTypeArgument = 4194304,
InTypeAlias = 8388608,
NodeBuilderFlagsMask = 848330095,
}
enum SymbolFormatFlags {
None = 0,
WriteTypeParametersOrArguments = 1,
UseOnlyExternalAliasing = 2,
AllowAnyNodeKind = 4,
UseAliasDefinedOutsideCurrentScope = 8,
}
enum TypePredicateKind {
This = 0,
Identifier = 1,
AssertsThis = 2,
AssertsIdentifier = 3,
}
interface TypePredicateBase {
kind: TypePredicateKind;
type: Type | undefined;
}
interface ThisTypePredicate extends TypePredicateBase {
kind: TypePredicateKind.This;
parameterName: undefined;
parameterIndex: undefined;
type: Type;
}
interface IdentifierTypePredicate extends TypePredicateBase {
kind: TypePredicateKind.Identifier;
parameterName: string;
parameterIndex: number;
type: Type;
}
interface AssertsThisTypePredicate extends TypePredicateBase {
kind: TypePredicateKind.AssertsThis;
parameterName: undefined;
parameterIndex: undefined;
type: Type | undefined;
}
interface AssertsIdentifierTypePredicate extends TypePredicateBase {
kind: TypePredicateKind.AssertsIdentifier;
parameterName: string;
parameterIndex: number;
type: Type | undefined;
}
type TypePredicate = ThisTypePredicate | IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate;
enum SymbolFlags {
None = 0,
FunctionScopedVariable = 1,
BlockScopedVariable = 2,
Property = 4,
EnumMember = 8,
Function = 16,
Class = 32,
Interface = 64,
ConstEnum = 128,
RegularEnum = 256,
ValueModule = 512,
NamespaceModule = 1024,
TypeLiteral = 2048,
ObjectLiteral = 4096,
Method = 8192,
Constructor = 16384,
GetAccessor = 32768,
SetAccessor = 65536,
Signature = 131072,
TypeParameter = 262144,
TypeAlias = 524288,
ExportValue = 1048576,
Alias = 2097152,
Prototype = 4194304,
ExportStar = 8388608,
Optional = 16777216,
Transient = 33554432,
Assignment = 67108864,
ModuleExports = 134217728,
All = -1,
Enum = 384,
Variable = 3,
Value = 111551,
Type = 788968,
Namespace = 1920,
Module = 1536,
Accessor = 98304,
FunctionScopedVariableExcludes = 111550,
BlockScopedVariableExcludes = 111551,
ParameterExcludes = 111551,
PropertyExcludes = 0,
EnumMemberExcludes = 900095,
FunctionExcludes = 110991,
ClassExcludes = 899503,
InterfaceExcludes = 788872,
RegularEnumExcludes = 899327,
ConstEnumExcludes = 899967,
ValueModuleExcludes = 110735,
NamespaceModuleExcludes = 0,
MethodExcludes = 103359,
GetAccessorExcludes = 46015,
SetAccessorExcludes = 78783,
AccessorExcludes = 13247,
TypeParameterExcludes = 526824,
TypeAliasExcludes = 788968,
AliasExcludes = 2097152,
ModuleMember = 2623475,
ExportHasLocal = 944,
BlockScoped = 418,
PropertyOrAccessor = 98308,
ClassMember = 106500,
}
interface Symbol {
flags: SymbolFlags;
escapedName: __String;
declarations?: Declaration[];
valueDeclaration?: Declaration;
members?: SymbolTable;
exports?: SymbolTable;
globalExports?: SymbolTable;
}
interface Symbol {
readonly name: string;
getFlags(): SymbolFlags;
getEscapedName(): __String;
getName(): string;
getDeclarations(): Declaration[] | undefined;
getDocumentationComment(typeChecker: TypeChecker | undefined): SymbolDisplayPart[];
getJsDocTags(checker?: TypeChecker): JSDocTagInfo[];
}
enum InternalSymbolName {
Call = "__call",
Constructor = "__constructor",
New = "__new",
Index = "__index",
ExportStar = "__export",
Global = "__global",
Missing = "__missing",
Type = "__type",
Object = "__object",
JSXAttributes = "__jsxAttributes",
Class = "__class",
Function = "__function",
Computed = "__computed",
Resolving = "__resolving__",
ExportEquals = "export=",
Default = "default",
This = "this",
InstantiationExpression = "__instantiationExpression",
ImportAttributes = "__importAttributes",
}
/**
* 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.
*/
type __String =
| (string & {
__escapedIdentifier: void;
})
| (void & {
__escapedIdentifier: void;
})
| InternalSymbolName;
/** @deprecated Use ReadonlyMap<__String, T> instead. */
type ReadonlyUnderscoreEscapedMap = ReadonlyMap<__String, T>;
/** @deprecated Use Map<__String, T> instead. */
type UnderscoreEscapedMap = Map<__String, T>;
/** SymbolTable based on ES6 Map interface. */
type SymbolTable = Map<__String, Symbol>;
enum TypeFlags {
Any = 1,
Unknown = 2,
String = 4,
Number = 8,
Boolean = 16,
Enum = 32,
BigInt = 64,
StringLiteral = 128,
NumberLiteral = 256,
BooleanLiteral = 512,
EnumLiteral = 1024,
BigIntLiteral = 2048,
ESSymbol = 4096,
UniqueESSymbol = 8192,
Void = 16384,
Undefined = 32768,
Null = 65536,
Never = 131072,
TypeParameter = 262144,
Object = 524288,
Union = 1048576,
Intersection = 2097152,
Index = 4194304,
IndexedAccess = 8388608,
Conditional = 16777216,
Substitution = 33554432,
NonPrimitive = 67108864,
TemplateLiteral = 134217728,
StringMapping = 268435456,
Literal = 2944,
Unit = 109472,
Freshable = 2976,
StringOrNumberLiteral = 384,
PossiblyFalsy = 117724,
StringLike = 402653316,
NumberLike = 296,
BigIntLike = 2112,
BooleanLike = 528,
EnumLike = 1056,
ESSymbolLike = 12288,
VoidLike = 49152,
UnionOrIntersection = 3145728,
StructuredType = 3670016,
TypeVariable = 8650752,
InstantiableNonPrimitive = 58982400,
InstantiablePrimitive = 406847488,
Instantiable = 465829888,
StructuredOrInstantiable = 469499904,
Narrowable = 536624127,
}
type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
interface Type {
flags: TypeFlags;
symbol: Symbol;
pattern?: DestructuringPattern;
aliasSymbol?: Symbol;
aliasTypeArguments?: readonly Type[];
}
interface Type {
getFlags(): TypeFlags;
getSymbol(): Symbol | undefined;
getProperties(): Symbol[];
getProperty(propertyName: string): Symbol | undefined;
getApparentProperties(): Symbol[];
getCallSignatures(): readonly Signature[];
getConstructSignatures(): readonly Signature[];
getStringIndexType(): Type | undefined;
getNumberIndexType(): Type | undefined;
getBaseTypes(): BaseType[] | undefined;
getNonNullableType(): Type;
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;
isClassOrInterface(): this is InterfaceType;
isClass(): this is InterfaceType;
isIndexType(): this is IndexType;
}
interface FreshableType extends Type {
freshType: FreshableType;
regularType: FreshableType;
}
interface LiteralType extends FreshableType {
value: string | number | PseudoBigInt;
}
interface UniqueESSymbolType extends Type {
symbol: Symbol;
escapedName: __String;
}
interface StringLiteralType extends LiteralType {
value: string;
}
interface NumberLiteralType extends LiteralType {
value: number;
}
interface BigIntLiteralType extends LiteralType {
value: PseudoBigInt;
}
interface EnumType extends FreshableType {
}
enum ObjectFlags {
None = 0,
Class = 1,
Interface = 2,
Reference = 4,
Tuple = 8,
Anonymous = 16,
Mapped = 32,
Instantiated = 64,
ObjectLiteral = 128,
EvolvingArray = 256,
ObjectLiteralPatternWithComputedProperties = 512,
ReverseMapped = 1024,
JsxAttributes = 2048,
JSLiteral = 4096,
FreshLiteral = 8192,
ArrayLiteral = 16384,
SingleSignatureType = 134217728,
ClassOrInterface = 3,
ContainsSpread = 2097152,
ObjectRestType = 4194304,
InstantiationExpressionType = 8388608,
}
interface ObjectType extends Type {
objectFlags: ObjectFlags;
}
/** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */
interface InterfaceType extends ObjectType {
typeParameters: TypeParameter[] | undefined;
outerTypeParameters: TypeParameter[] | undefined;
localTypeParameters: TypeParameter[] | undefined;
thisType: TypeParameter | undefined;
}
type BaseType = ObjectType | IntersectionType | TypeVariable;
interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
declaredProperties: Symbol[];
declaredCallSignatures: Signature[];
declaredConstructSignatures: Signature[];
declaredIndexInfos: IndexInfo[];
}
/**
* Type references (ObjectFlags.Reference). When a class or interface has type parameters or
* a "this" type, references to the class or interface are made using type references. The
* typeArguments property specifies the types to substitute for the type parameters of the
* class or interface and optionally includes an extra element that specifies the type to
* substitute for "this" in the resulting instantiation. When no extra argument is present,
* the type reference itself is substituted for "this". The typeArguments property is undefined
* if the class or interface has no type parameters and the reference isn't specifying an
* explicit "this" argument.
*/
interface TypeReference extends ObjectType {
target: GenericType;
node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
}
interface TypeReference {
typeArguments?: readonly Type[];
}
interface DeferredTypeReference extends TypeReference {
}
interface GenericType extends InterfaceType, TypeReference {
}
enum ElementFlags {
Required = 1,
Optional = 2,
Rest = 4,
Variadic = 8,
Fixed = 3,
Variable = 12,
NonRequired = 14,
NonRest = 11,
}
interface TupleType extends GenericType {
elementFlags: readonly ElementFlags[];
/** Number of required or variadic elements */
minLength: number;
/** Number of initial required or optional elements */
fixedLength: number;
/**
* True if tuple has any rest or variadic elements
*
* @deprecated Use `.combinedFlags & ElementFlags.Variable` instead
*/
hasRestElement: boolean;
combinedFlags: ElementFlags;
readonly: boolean;
labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration | undefined)[];
}
interface TupleTypeReference extends TypeReference {
target: TupleType;
}
interface UnionOrIntersectionType extends Type {
types: Type[];
}
interface UnionType extends UnionOrIntersectionType {
}
interface IntersectionType extends UnionOrIntersectionType {
}
type StructuredType = ObjectType | UnionType | IntersectionType;
interface EvolvingArrayType extends ObjectType {
elementType: Type;
finalArrayType?: Type;
}
interface InstantiableType extends Type {
}
interface TypeParameter extends InstantiableType {
}
interface IndexedAccessType extends InstantiableType {
objectType: Type;
indexType: Type;
constraint?: Type;
simplifiedForReading?: Type;
simplifiedForWriting?: Type;
}
type TypeVariable = TypeParameter | IndexedAccessType;
interface IndexType extends InstantiableType {
type: InstantiableType | UnionOrIntersectionType;
}
interface ConditionalRoot {
node: ConditionalTypeNode;
checkType: Type;
extendsType: Type;
isDistributive: boolean;
inferTypeParameters?: TypeParameter[];
outerTypeParameters?: TypeParameter[];
instantiations?: Map;
aliasSymbol?: Symbol;
aliasTypeArguments?: Type[];
}
interface ConditionalType extends InstantiableType {
root: ConditionalRoot;
checkType: Type;
extendsType: Type;
resolvedTrueType?: Type;
resolvedFalseType?: Type;
}
interface TemplateLiteralType extends InstantiableType {
texts: readonly string[];
types: readonly Type[];
}
interface StringMappingType extends InstantiableType {
symbol: Symbol;
type: Type;
}
interface SubstitutionType extends InstantiableType {
objectFlags: ObjectFlags;
baseType: Type;
constraint: Type;
}
enum SignatureKind {
Call = 0,
Construct = 1,
}
interface Signature {
declaration?: SignatureDeclaration | JSDocSignature;
typeParameters?: readonly TypeParameter[];
parameters: readonly Symbol[];
thisParameter?: Symbol;
}
interface Signature {
getDeclaration(): SignatureDeclaration;
getTypeParameters(): TypeParameter[] | undefined;
getParameters(): Symbol[];
getTypeParameterAtPosition(pos: number): Type;
getReturnType(): Type;
getDocumentationComment(typeChecker: TypeChecker | undefined): SymbolDisplayPart[];
getJsDocTags(): JSDocTagInfo[];
}
enum IndexKind {
String = 0,
Number = 1,
}
type ElementWithComputedPropertyName = (ClassElement | ObjectLiteralElement) & {
name: ComputedPropertyName;
};
interface IndexInfo {
keyType: Type;
type: Type;
isReadonly: boolean;
declaration?: IndexSignatureDeclaration;
components?: ElementWithComputedPropertyName[];
}
enum InferencePriority {
None = 0,
NakedTypeVariable = 1,
SpeculativeTuple = 2,
SubstituteSource = 4,
HomomorphicMappedType = 8,
PartialHomomorphicMappedType = 16,
MappedTypeConstraint = 32,
ContravariantConditional = 64,
ReturnType = 128,
LiteralKeyof = 256,
NoConstraints = 512,
AlwaysStrict = 1024,
MaxValue = 2048,
PriorityImpliesCombination = 416,
Circularity = -1,
}
interface FileExtensionInfo {
extension: string;
isMixedContent: boolean;
scriptKind?: ScriptKind;
}
interface DiagnosticMessage {
key: string;
category: DiagnosticCategory;
code: number;
message: string;
reportsUnnecessary?: {};
reportsDeprecated?: {};
}
/**
* 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.
*/
interface DiagnosticMessageChain {
messageText: string;
category: DiagnosticCategory;
code: number;
next?: DiagnosticMessageChain[];
}
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?: {};
reportsDeprecated?: {};
source?: string;
relatedInformation?: DiagnosticRelatedInformation[];
}
interface DiagnosticRelatedInformation {
category: DiagnosticCategory;
code: number;
file: SourceFile | undefined;
start: number | undefined;
length: number | undefined;
messageText: string | DiagnosticMessageChain;
}
interface DiagnosticWithLocation extends Diagnostic {
file: SourceFile;
start: number;
length: number;
}
enum DiagnosticCategory {
Warning = 0,
Error = 1,
Suggestion = 2,
Message = 3,
}
enum ModuleResolutionKind {
Classic = 1,
/**
* @deprecated
* `NodeJs` was renamed to `Node10` to better reflect the version of Node that it targets.
* Use the new name or consider switching to a modern module resolution target.
*/
NodeJs = 2,
Node10 = 2,
Node16 = 3,
NodeNext = 99,
Bundler = 100,
}
enum ModuleDetectionKind {
/**
* Files with imports, exports and/or import.meta are considered modules
*/
Legacy = 1,
/**
* Legacy, but also files with jsx under react-jsx or react-jsxdev and esm mode files under moduleResolution: node16+
*/
Auto = 2,
/**
* Consider all non-declaration files modules, regardless of present syntax
*/
Force = 3,
}
interface PluginImport {
name: string;
}
interface ProjectReference {
/** A normalized path on disk */
path: string;
/** The path as the user originally wrote it */
originalPath?: string;
/** @deprecated */
prepend?: boolean;
/** True if it is intended that this reference form a circularity */
circular?: boolean;
}
enum WatchFileKind {
FixedPollingInterval = 0,
PriorityPollingInterval = 1,
DynamicPriorityPolling = 2,
FixedChunkSizePolling = 3,
UseFsEvents = 4,
UseFsEventsOnParentDirectory = 5,
}
enum WatchDirectoryKind {
UseFsEvents = 0,
FixedPollingInterval = 1,
DynamicPriorityPolling = 2,
FixedChunkSizePolling = 3,
}
enum PollingWatchKind {
FixedInterval = 0,
PriorityInterval = 1,
DynamicPriority = 2,
FixedChunkSize = 3,
}
type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike | PluginImport[] | ProjectReference[] | null | undefined;
interface CompilerOptions {
allowImportingTsExtensions?: boolean;
allowJs?: boolean;
allowArbitraryExtensions?: boolean;
allowSyntheticDefaultImports?: boolean;
allowUmdGlobalAccess?: boolean;
allowUnreachableCode?: boolean;
allowUnusedLabels?: boolean;
alwaysStrict?: boolean;
baseUrl?: string;
/** @deprecated */
charset?: string;
checkJs?: boolean;
customConditions?: string[];
declaration?: boolean;
declarationMap?: boolean;
emitDeclarationOnly?: boolean;
declarationDir?: string;
disableSizeLimit?: boolean;
disableSourceOfProjectReferenceRedirect?: boolean;
disableSolutionSearching?: boolean;
disableReferencedProjectLoad?: boolean;
downlevelIteration?: boolean;
emitBOM?: boolean;
emitDecoratorMetadata?: boolean;
exactOptionalPropertyTypes?: boolean;
experimentalDecorators?: boolean;
forceConsistentCasingInFileNames?: boolean;
ignoreDeprecations?: string;
importHelpers?: boolean;
/** @deprecated */
importsNotUsedAsValues?: ImportsNotUsedAsValues;
inlineSourceMap?: boolean;
inlineSources?: boolean;
isolatedModules?: boolean;
isolatedDeclarations?: boolean;
jsx?: JsxEmit;
/** @deprecated */
keyofStringsOnly?: boolean;
lib?: string[];
libReplacement?: boolean;
locale?: string;
mapRoot?: string;
maxNodeModuleJsDepth?: number;
module?: ModuleKind;
moduleResolution?: ModuleResolutionKind;
moduleSuffixes?: string[];
moduleDetection?: ModuleDetectionKind;
newLine?: NewLineKind;
noEmit?: boolean;
noCheck?: boolean;
noEmitHelpers?: boolean;
noEmitOnError?: boolean;
noErrorTruncation?: boolean;
noFallthroughCasesInSwitch?: boolean;
noImplicitAny?: boolean;
noImplicitReturns?: boolean;
noImplicitThis?: boolean;
/** @deprecated */
noStrictGenericChecks?: boolean;
noUnusedLocals?: boolean;
noUnusedParameters?: boolean;
/** @deprecated */
noImplicitUseStrict?: boolean;
noPropertyAccessFromIndexSignature?: boolean;
assumeChangesOnlyAffectDirectDependencies?: boolean;
noLib?: boolean;
noResolve?: boolean;
noUncheckedIndexedAccess?: boolean;
/** @deprecated */
out?: string;
outDir?: string;
outFile?: string;
paths?: MapLike;
preserveConstEnums?: boolean;
noImplicitOverride?: boolean;
preserveSymlinks?: boolean;
/** @deprecated */
preserveValueImports?: boolean;
project?: string;
reactNamespace?: string;
jsxFactory?: string;
jsxFragmentFactory?: string;
jsxImportSource?: string;
composite?: boolean;
incremental?: boolean;
tsBuildInfoFile?: string;
removeComments?: boolean;
resolvePackageJsonExports?: boolean;
resolvePackageJsonImports?: boolean;
rewriteRelativeImportExtensions?: boolean;
rootDir?: string;
rootDirs?: string[];
skipLibCheck?: boolean;
skipDefaultLibCheck?: boolean;
sourceMap?: boolean;
sourceRoot?: string;
strict?: boolean;
strictFunctionTypes?: boolean;
strictBindCallApply?: boolean;
strictNullChecks?: boolean;
strictPropertyInitialization?: boolean;
strictBuiltinIteratorReturn?: boolean;
stripInternal?: boolean;
/** @deprecated */
suppressExcessPropertyErrors?: boolean;
/** @deprecated */
suppressImplicitAnyIndexErrors?: boolean;
target?: ScriptTarget;
traceResolution?: boolean;
useUnknownInCatchVariables?: boolean;
noUncheckedSideEffectImports?: boolean;
resolveJsonModule?: boolean;
types?: string[];
/** Paths used to compute primary types search locations */
typeRoots?: string[];
verbatimModuleSyntax?: boolean;
erasableSyntaxOnly?: boolean;
esModuleInterop?: boolean;
useDefineForClassFields?: boolean;
[option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
}
interface WatchOptions {
watchFile?: WatchFileKind;
watchDirectory?: WatchDirectoryKind;
fallbackPolling?: PollingWatchKind;
synchronousWatchDirectory?: boolean;
excludeDirectories?: string[];
excludeFiles?: string[];
[option: string]: CompilerOptionsValue | undefined;
}
interface TypeAcquisition {
enable?: boolean;
include?: string[];
exclude?: string[];
disableFilenameBasedTypeAcquisition?: boolean;
[option: string]: CompilerOptionsValue | undefined;
}
enum ModuleKind {
None = 0,
CommonJS = 1,
AMD = 2,
UMD = 3,
System = 4,
ES2015 = 5,
ES2020 = 6,
ES2022 = 7,
ESNext = 99,
Node16 = 100,
Node18 = 101,
Node20 = 102,
NodeNext = 199,
Preserve = 200,
}
enum JsxEmit {
None = 0,
Preserve = 1,
React = 2,
ReactNative = 3,
ReactJSX = 4,
ReactJSXDev = 5,
}
/** @deprecated */
enum ImportsNotUsedAsValues {
Remove = 0,
Preserve = 1,
Error = 2,
}
enum NewLineKind {
CarriageReturnLineFeed = 0,
LineFeed = 1,
}
interface LineAndCharacter {
/** 0-based. */
line: number;
character: number;
}
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,
}
enum ScriptTarget {
/** @deprecated */
ES3 = 0,
ES5 = 1,
ES2015 = 2,
ES2016 = 3,
ES2017 = 4,
ES2018 = 5,
ES2019 = 6,
ES2020 = 7,
ES2021 = 8,
ES2022 = 9,
ES2023 = 10,
ES2024 = 11,
ESNext = 99,
JSON = 100,
Latest = 99,
}
enum LanguageVariant {
Standard = 0,
JSX = 1,
}
/** Either a parsed command line or a parsed tsconfig.json */
interface ParsedCommandLine {
options: CompilerOptions;
typeAcquisition?: TypeAcquisition;
fileNames: string[];
projectReferences?: readonly ProjectReference[];
watchOptions?: WatchOptions;
raw?: any;
errors: Diagnostic[];
wildcardDirectories?: MapLike;
compileOnSave?: boolean;
}
enum WatchDirectoryFlags {
None = 0,
Recursive = 1,
}
interface CreateProgramOptions {
rootNames: readonly string[];
options: CompilerOptions;
projectReferences?: readonly ProjectReference[];
host?: CompilerHost;
oldProgram?: Program;
configFileParsingDiagnostics?: readonly Diagnostic[];
}
interface ModuleResolutionHost {
fileExists(fileName: string): boolean;
readFile(fileName: string): string | undefined;
trace?(s: string): void;
directoryExists?(directoryName: string): boolean;
/**
* Resolve a symbolic link.
* @see https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options
*/
realpath?(path: string): string;
getCurrentDirectory?(): string;
getDirectories?(path: string): string[];
useCaseSensitiveFileNames?: boolean | (() => boolean) | undefined;
}
/**
* Used by services to specify the minimum host area required to set up source files under any compilation settings
*/
interface MinimalResolutionCacheHost extends ModuleResolutionHost {
getCompilationSettings(): CompilerOptions;
getCompilerHost?(): CompilerHost | undefined;
}
/**
* Represents the result of module resolution.
* Module resolution will pick up tsx/jsx/js files even if '--jsx' and '--allowJs' are turned off.
* The Program will then filter results based on these flags.
*
* Prefer to return a `ResolvedModuleFull` so that the file type does not have to be inferred.
*/
interface ResolvedModule {
/** Path of the file the module was resolved to. */
resolvedFileName: string;
/** True if `resolvedFileName` comes from `node_modules`. */
isExternalLibraryImport?: boolean;
/**
* True if the original module reference used a .ts extension to refer directly to a .ts file,
* which should produce an error during checking if emit is enabled.
*/
resolvedUsingTsExtension?: boolean;
}
/**
* ResolvedModule with an explicitly provided `extension` property.
* Prefer this over `ResolvedModule`.
* If changing this, remember to change `moduleResolutionIsEqualTo`.
*/
interface ResolvedModuleFull extends ResolvedModule {
/**
* Extension of resolvedFileName. This must match what's at the end of resolvedFileName.
* This is optional for backwards-compatibility, but will be added if not provided.
*/
extension: string;
packageId?: PackageId;
}
/**
* Unique identifier with a package name and version.
* If changing this, remember to change `packageIdIsEqual`.
*/
interface PackageId {
/**
* Name of the package.
* Should not include `@types`.
* If accessing a non-index file, this should include its name e.g. "foo/bar".
*/
name: string;
/**
* Name of a submodule within this package.
* May be "".
*/
subModuleName: string;
/** Version of the package, e.g. "1.2.3" */
version: string;
}
enum Extension {
Ts = ".ts",
Tsx = ".tsx",
Dts = ".d.ts",
Js = ".js",
Jsx = ".jsx",
Json = ".json",
TsBuildInfo = ".tsbuildinfo",
Mjs = ".mjs",
Mts = ".mts",
Dmts = ".d.mts",
Cjs = ".cjs",
Cts = ".cts",
Dcts = ".d.cts",
}
interface ResolvedModuleWithFailedLookupLocations {
readonly resolvedModule: ResolvedModuleFull | undefined;
}
interface ResolvedTypeReferenceDirective {
primary: boolean;
resolvedFileName: string | undefined;
packageId?: PackageId;
/** True if `resolvedFileName` comes from `node_modules`. */
isExternalLibraryImport?: boolean;
}
interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
readonly resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined;
}
interface CompilerHost extends ModuleResolutionHost {
getSourceFile(fileName: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined;
getSourceFileByPath?(fileName: string, path: Path, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined;
getCancellationToken?(): CancellationToken;
getDefaultLibFileName(options: CompilerOptions): string;
getDefaultLibLocation?(): string;
writeFile: WriteFileCallback;
getCurrentDirectory(): string;
getCanonicalFileName(fileName: string): string;
useCaseSensitiveFileNames(): boolean;
getNewLine(): string;
readDirectory?(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): string[];
/** @deprecated supply resolveModuleNameLiterals instead for resolution that can handle newer resolution modes like nodenext */
resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
/**
* Returns the module resolution cache used by a provided `resolveModuleNames` implementation so that any non-name module resolution operations (eg, package.json lookup) can reuse it
*/
getModuleResolutionCache?(): ModuleResolutionCache | undefined;
/**
* @deprecated supply resolveTypeReferenceDirectiveReferences instead for resolution that can handle newer resolution modes like nodenext
*
* This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
*/
resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: ResolutionMode): (ResolvedTypeReferenceDirective | undefined)[];
resolveModuleNameLiterals?(moduleLiterals: readonly StringLiteralLike[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile, reusedNames: readonly StringLiteralLike[] | undefined): readonly ResolvedModuleWithFailedLookupLocations[];
resolveTypeReferenceDirectiveReferences?(typeDirectiveReferences: readonly T[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile | undefined, reusedNames: readonly T[] | undefined): readonly ResolvedTypeReferenceDirectiveWithFailedLookupLocations[];
getEnvironmentVariable?(name: string): string | undefined;
/** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
hasInvalidatedResolutions?(filePath: Path): boolean;
createHash?(data: string): string;
getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
jsDocParsingMode?: JSDocParsingMode;
}
interface SourceMapRange extends TextRange {
source?: SourceMapSource;
}
interface SourceMapSource {
fileName: string;
text: string;
skipTrivia?: (pos: number) => number;
}
interface SourceMapSource {
getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
}
enum EmitFlags {
None = 0,
SingleLine = 1,
MultiLine = 2,
AdviseOnEmitNode = 4,
NoSubstitution = 8,
CapturesThis = 16,
NoLeadingSourceMap = 32,
NoTrailingSourceMap = 64,
NoSourceMap = 96,
NoNestedSourceMaps = 128,
NoTokenLeadingSourceMaps = 256,
NoTokenTrailingSourceMaps = 512,
NoTokenSourceMaps = 768,
NoLeadingComments = 1024,
NoTrailingComments = 2048,
NoComments = 3072,
NoNestedComments = 4096,
HelperName = 8192,
ExportName = 16384,
LocalName = 32768,
InternalName = 65536,
Indented = 131072,
NoIndentation = 262144,
AsyncFunctionBody = 524288,
ReuseTempVariableScope = 1048576,
CustomPrologue = 2097152,
NoHoisting = 4194304,
Iterator = 8388608,
NoAsciiEscaping = 16777216,
}
interface EmitHelperBase {
readonly name: string;
readonly scoped: boolean;
readonly text: string | ((node: EmitHelperUniqueNameCallback) => string);
readonly priority?: number;
readonly dependencies?: EmitHelper[];
}
interface ScopedEmitHelper extends EmitHelperBase {
readonly scoped: true;
}
interface UnscopedEmitHelper extends EmitHelperBase {
readonly scoped: false;
readonly text: string;
}
type EmitHelper = ScopedEmitHelper | UnscopedEmitHelper;
type EmitHelperUniqueNameCallback = (name: string) => string;
enum EmitHint {
SourceFile = 0,
Expression = 1,
IdentifierName = 2,
MappedTypeParameter = 3,
Unspecified = 4,
EmbeddedStatement = 5,
JsxAttributeValue = 6,
ImportTypeNodeAttributes = 7,
}
enum OuterExpressionKinds {
Parentheses = 1,
TypeAssertions = 2,
NonNullAssertions = 4,
PartiallyEmittedExpressions = 8,
ExpressionsWithTypeArguments = 16,
Satisfies = 32,
Assertions = 38,
All = 63,
ExcludeJSDocTypeAssertion = -2147483648,
}
type ImmediatelyInvokedFunctionExpression = CallExpression & {
readonly expression: FunctionExpression;
};
type ImmediatelyInvokedArrowFunction = CallExpression & {
readonly expression: ParenthesizedExpression & {
readonly expression: ArrowFunction;
};
};
interface NodeFactory {
createNodeArray(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray;
createNumericLiteral(value: string | number, numericLiteralFlags?: TokenFlags): NumericLiteral;
createBigIntLiteral(value: string | PseudoBigInt): BigIntLiteral;
createStringLiteral(text: string, isSingleQuote?: boolean): StringLiteral;
createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier, isSingleQuote?: boolean): StringLiteral;
createRegularExpressionLiteral(text: string): RegularExpressionLiteral;
createIdentifier(text: string): Identifier;
/**
* Create a unique temporary variable.
* @param recordTempVariable An optional callback used to record the temporary variable name. This
* should usually be a reference to `hoistVariableDeclaration` from a `TransformationContext`, but
* can be `undefined` if you plan to record the temporary variable manually.
* @param reservedInNestedScopes When `true`, reserves the temporary variable name in all nested scopes
* during emit so that the variable can be referenced in a nested function body. This is an alternative to
* setting `EmitFlags.ReuseTempVariableScope` on the nested function itself.
*/
createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean): Identifier;
/**
* Create a unique temporary variable for use in a loop.
* @param reservedInNestedScopes When `true`, reserves the temporary variable name in all nested scopes
* during emit so that the variable can be referenced in a nested function body. This is an alternative to
* setting `EmitFlags.ReuseTempVariableScope` on the nested function itself.
*/
createLoopVariable(reservedInNestedScopes?: boolean): Identifier;
/** Create a unique name based on the supplied text. */
createUniqueName(text: string, flags?: GeneratedIdentifierFlags): Identifier;
/** Create a unique name generated for a node. */
getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier;
createPrivateIdentifier(text: string): PrivateIdentifier;
createUniquePrivateName(text?: string): PrivateIdentifier;
getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier;
createToken(token: SyntaxKind.SuperKeyword): SuperExpression;
createToken(token: SyntaxKind.ThisKeyword): ThisExpression;
createToken(token: SyntaxKind.NullKeyword): NullLiteral;
createToken(token: SyntaxKind.TrueKeyword): TrueLiteral;
createToken(token: SyntaxKind.FalseKeyword): FalseLiteral;
createToken(token: SyntaxKind.EndOfFileToken): EndOfFileToken;
createToken(token: SyntaxKind.Unknown): Token;
createToken(token: TKind): PunctuationToken;
createToken(token: TKind): KeywordTypeNode;
createToken(token: TKind): ModifierToken;
createToken(token: TKind): KeywordToken;
createSuper(): SuperExpression;
createThis(): ThisExpression;
createNull(): NullLiteral;
createTrue(): TrueLiteral;
createFalse(): FalseLiteral;
createModifier(kind: T): ModifierToken;
createModifiersFromModifierFlags(flags: ModifierFlags): Modifier[] | undefined;
createQualifiedName(left: EntityName, right: string | Identifier): QualifiedName;
updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName;
createComputedPropertyName(expression: Expression): ComputedPropertyName;
updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName;
createTypeParameterDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
createParameterDeclaration(modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
updateParameterDeclaration(node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
createDecorator(expression: Expression): Decorator;
updateDecorator(node: Decorator, expression: Expression): Decorator;
createPropertySignature(modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined): PropertySignature;
updatePropertySignature(node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined): PropertySignature;
createPropertyDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
updatePropertyDeclaration(node: PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
createMethodSignature(modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): MethodSignature;
updateMethodSignature(node: MethodSignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): MethodSignature;
createMethodDeclaration(modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
updateMethodDeclaration(node: MethodDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
createConstructorDeclaration(modifiers: readonly ModifierLike[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
updateConstructorDeclaration(node: ConstructorDeclaration, modifiers: readonly ModifierLike[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
createGetAccessorDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
updateGetAccessorDeclaration(node: GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
createSetAccessorDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
updateSetAccessorDeclaration(node: SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
createCallSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): CallSignatureDeclaration;
updateCallSignature(node: CallSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): CallSignatureDeclaration;
createConstructSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): ConstructSignatureDeclaration;
updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): ConstructSignatureDeclaration;
createIndexSignature(modifiers: readonly ModifierLike[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
updateIndexSignature(node: IndexSignatureDeclaration, modifiers: readonly ModifierLike[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan;
updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan;
createClassStaticBlockDeclaration(body: Block): ClassStaticBlockDeclaration;
updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, body: Block): ClassStaticBlockDeclaration;
createKeywordTypeNode(kind: TKind): KeywordTypeNode;
createTypePredicateNode(assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode;
updateTypePredicateNode(node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode;
createTypeReferenceNode(typeName: string | EntityName, typeArguments?: readonly TypeNode[]): TypeReferenceNode;
updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray | undefined): TypeReferenceNode;
createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): FunctionTypeNode;
updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode): FunctionTypeNode;
createConstructorTypeNode(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
updateConstructorTypeNode(node: ConstructorTypeNode, modifiers: readonly Modifier[] | undefined, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode): ConstructorTypeNode;
createTypeQueryNode(exprName: EntityName, typeArguments?: readonly TypeNode[]): TypeQueryNode;
updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName, typeArguments?: readonly TypeNode[]): TypeQueryNode;
createTypeLiteralNode(members: readonly TypeElement[] | undefined): TypeLiteralNode;
updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray): TypeLiteralNode;
createArrayTypeNode(elementType: TypeNode): ArrayTypeNode;
updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode;
createTupleTypeNode(elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode;
updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode;
createNamedTupleMember(dotDotDotToken: DotDotDotToken | undefined, name: Identifier, questionToken: QuestionToken | undefined, type: TypeNode): NamedTupleMember;
updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: DotDotDotToken | undefined, name: Identifier, questionToken: QuestionToken | undefined, type: TypeNode): NamedTupleMember;
createOptionalTypeNode(type: TypeNode): OptionalTypeNode;
updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode;
createRestTypeNode(type: TypeNode): RestTypeNode;
updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode;
createUnionTypeNode(types: readonly TypeNode[]): UnionTypeNode;
updateUnionTypeNode(node: UnionTypeNode, types: NodeArray): UnionTypeNode;
createIntersectionTypeNode(types: readonly TypeNode[]): IntersectionTypeNode;
updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray): IntersectionTypeNode;
createConditionalTypeNode(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
updateConditionalTypeNode(node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
createInferTypeNode(typeParameter: TypeParameterDeclaration): InferTypeNode;
updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration): InferTypeNode;
createImportTypeNode(argument: TypeNode, attributes?: ImportAttributes, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, attributes: ImportAttributes | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
createThisTypeNode(): ThisTypeNode;
createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
createMappedTypeNode(readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray | undefined): MappedTypeNode;
updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray | undefined): MappedTypeNode;
createLiteralTypeNode(literal: LiteralTypeNode["literal"]): LiteralTypeNode;
updateLiteralTypeNode(node: LiteralTypeNode, literal: LiteralTypeNode["literal"]): LiteralTypeNode;
createTemplateLiteralType(head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]): TemplateLiteralTypeNode;
updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]): TemplateLiteralTypeNode;
createObjectBindingPattern(elements: readonly BindingElement[]): ObjectBindingPattern;
updateObjectBindingPattern(node: ObjectBindingPattern, elements: readonly BindingElement[]): ObjectBindingPattern;
createArrayBindingPattern(elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement;
updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement;
createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression;
updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression;
createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression;
updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression;
createPropertyAccessExpression(expression: Expression, name: string | MemberName): PropertyAccessExpression;
updatePropertyAccessExpression(node: PropertyAccessExpression, expression: Expression, name: MemberName): PropertyAccessExpression;
createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | MemberName): PropertyAccessChain;
updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: MemberName): PropertyAccessChain;
createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression;
updateElementAccessExpression(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression;
createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain;
updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain;
createCallExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression;
updateCallExpression(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression;
createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain;
updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain;
createNewExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression;
updateNewExpression(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression;
createTaggedTemplateExpression(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion;
updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion;
createParenthesizedExpression(expression: Expression): ParenthesizedExpression;
updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression;
createFunctionExpression(modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block): FunctionExpression;
updateFunctionExpression(node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression;
createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
createDeleteExpression(expression: Expression): DeleteExpression;
updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression;
createTypeOfExpression(expression: Expression): TypeOfExpression;
updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression;
createVoidExpression(expression: Expression): VoidExpression;
updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression;
createAwaitExpression(expression: Expression): AwaitExpression;
updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression;
createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression;
updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression;
createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression;
updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression;
createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression;
updateConditionalExpression(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
createTemplateHead(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateHead;
createTemplateHead(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateHead;
createTemplateMiddle(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateMiddle;
createTemplateMiddle(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateMiddle;
createTemplateTail(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateTail;
createTemplateTail(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateTail;
createNoSubstitutionTemplateLiteral(text: string, rawText?: string): NoSubstitutionTemplateLiteral;
createNoSubstitutionTemplateLiteral(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral;
createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression;
createYieldExpression(asteriskToken: undefined, expression: Expression | undefined): YieldExpression;
updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression;
createSpreadElement(expression: Expression): SpreadElement;
updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement;
createClassExpression(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
updateClassExpression(node: ClassExpression, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
createOmittedExpression(): OmittedExpression;
createExpressionWithTypeArguments(expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
createAsExpression(expression: Expression, type: TypeNode): AsExpression;
updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression;
createNonNullExpression(expression: Expression): NonNullExpression;
updateNonNullExpression(node: NonNullExpression, expression: Expression): NonNullExpression;
createNonNullChain(expression: Expression): NonNullChain;
updateNonNullChain(node: NonNullChain, expression: Expression): NonNullChain;
createMetaProperty(keywordToken: MetaProperty["keywordToken"], name: Identifier): MetaProperty;
updateMetaProperty(node: MetaProperty, name: Identifier): MetaProperty;
createSatisfiesExpression(expression: Expression, type: TypeNode): SatisfiesExpression;
updateSatisfiesExpression(node: SatisfiesExpression, expression: Expression, type: TypeNode): SatisfiesExpression;
createTemplateSpan(expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
createSemicolonClassElement(): SemicolonClassElement;
createBlock(statements: readonly Statement[], multiLine?: boolean): Block;
updateBlock(node: Block, statements: readonly Statement[]): Block;
createVariableStatement(modifiers: readonly ModifierLike[] | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]): VariableStatement;
updateVariableStatement(node: VariableStatement, modifiers: readonly ModifierLike[] | undefined, declarationList: VariableDeclarationList): VariableStatement;
createEmptyStatement(): EmptyStatement;
createExpressionStatement(expression: Expression): ExpressionStatement;
updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement;
createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement;
updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement;
createDoStatement(statement: Statement, expression: Expression): DoStatement;
updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement;
createWhileStatement(expression: Expression, statement: Statement): WhileStatement;
updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement;
createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
updateForStatement(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
createForOfStatement(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
updateForOfStatement(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
createContinueStatement(label?: string | Identifier): ContinueStatement;
updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement;
createBreakStatement(label?: string | Identifier): BreakStatement;
updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement;
createReturnStatement(expression?: Expression): ReturnStatement;
updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement;
createWithStatement(expression: Expression, statement: Statement): WithStatement;
updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement;
createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement;
updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement;
createLabeledStatement(label: string | Identifier, statement: Statement): LabeledStatement;
updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement;
createThrowStatement(expression: Expression): ThrowStatement;
updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement;
createTryStatement(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
createDebuggerStatement(): DebuggerStatement;
createVariableDeclaration(name: string | BindingName, exclamationToken?: ExclamationToken, type?: TypeNode, initializer?: Expression): VariableDeclaration;
updateVariableDeclaration(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList;
updateVariableDeclarationList(node: VariableDeclarationList, declarations: readonly VariableDeclaration[]): VariableDeclarationList;
createFunctionDeclaration(modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
updateFunctionDeclaration(node: FunctionDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
createClassDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
updateClassDeclaration(node: ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
createInterfaceDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
updateInterfaceDeclaration(node: InterfaceDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
createTypeAliasDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
updateTypeAliasDeclaration(node: TypeAliasDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
createEnumDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
updateEnumDeclaration(node: EnumDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
createModuleDeclaration(modifiers: readonly ModifierLike[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
updateModuleDeclaration(node: ModuleDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
createModuleBlock(statements: readonly Statement[]): ModuleBlock;
updateModuleBlock(node: ModuleBlock, statements: readonly Statement[]): ModuleBlock;
createCaseBlock(clauses: readonly CaseOrDefaultClause[]): CaseBlock;
updateCaseBlock(node: CaseBlock, clauses: readonly CaseOrDefaultClause[]): CaseBlock;
createNamespaceExportDeclaration(name: string | Identifier): NamespaceExportDeclaration;
updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration;
createImportEqualsDeclaration(modifiers: readonly ModifierLike[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
updateImportEqualsDeclaration(node: ImportEqualsDeclaration, modifiers: readonly ModifierLike[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
createImportDeclaration(modifiers: readonly ModifierLike[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, attributes?: ImportAttributes): ImportDeclaration;
updateImportDeclaration(node: ImportDeclaration, modifiers: readonly ModifierLike[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, attributes: ImportAttributes | undefined): ImportDeclaration;
createImportClause(phaseModifier: ImportPhaseModifierSyntaxKind | undefined, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
/** @deprecated */ createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
updateImportClause(node: ImportClause, phaseModifier: ImportPhaseModifierSyntaxKind | undefined, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
/** @deprecated */ updateImportClause(node: ImportClause, isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
/** @deprecated */ createAssertClause(elements: NodeArray, multiLine?: boolean): AssertClause;
/** @deprecated */ updateAssertClause(node: AssertClause, elements: NodeArray, multiLine?: boolean): AssertClause;
/** @deprecated */ createAssertEntry(name: AssertionKey, value: Expression): AssertEntry;
/** @deprecated */ updateAssertEntry(node: AssertEntry, name: AssertionKey, value: Expression): AssertEntry;
/** @deprecated */ createImportTypeAssertionContainer(clause: AssertClause, multiLine?: boolean): ImportTypeAssertionContainer;
/** @deprecated */ updateImportTypeAssertionContainer(node: ImportTypeAssertionContainer, clause: AssertClause, multiLine?: boolean): ImportTypeAssertionContainer;
createImportAttributes(elements: NodeArray, multiLine?: boolean): ImportAttributes;
updateImportAttributes(node: ImportAttributes, elements: NodeArray, multiLine?: boolean): ImportAttributes;
createImportAttribute(name: ImportAttributeName, value: Expression): ImportAttribute;
updateImportAttribute(node: ImportAttribute, name: ImportAttributeName, value: Expression): ImportAttribute;
createNamespaceImport(name: Identifier): NamespaceImport;
updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport;
createNamespaceExport(name: ModuleExportName): NamespaceExport;
updateNamespaceExport(node: NamespaceExport, name: ModuleExportName): NamespaceExport;
createNamedImports(elements: readonly ImportSpecifier[]): NamedImports;
updateNamedImports(node: NamedImports, elements: readonly ImportSpecifier[]): NamedImports;
createImportSpecifier(isTypeOnly: boolean, propertyName: ModuleExportName | undefined, name: Identifier): ImportSpecifier;
updateImportSpecifier(node: ImportSpecifier, isTypeOnly: boolean, propertyName: ModuleExportName | undefined, name: Identifier): ImportSpecifier;
createExportAssignment(modifiers: readonly ModifierLike[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
updateExportAssignment(node: ExportAssignment, modifiers: readonly ModifierLike[] | undefined, expression: Expression): ExportAssignment;
createExportDeclaration(modifiers: readonly ModifierLike[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, attributes?: ImportAttributes): ExportDeclaration;
updateExportDeclaration(node: ExportDeclaration, modifiers: readonly ModifierLike[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, attributes: ImportAttributes | undefined): ExportDeclaration;
createNamedExports(elements: readonly ExportSpecifier[]): NamedExports;
updateNamedExports(node: NamedExports, elements: readonly ExportSpecifier[]): NamedExports;
createExportSpecifier(isTypeOnly: boolean, propertyName: string | ModuleExportName | undefined, name: string | ModuleExportName): ExportSpecifier;
updateExportSpecifier(node: ExportSpecifier, isTypeOnly: boolean, propertyName: ModuleExportName | undefined, name: ModuleExportName): ExportSpecifier;
createExternalModuleReference(expression: Expression): ExternalModuleReference;
updateExternalModuleReference(node: ExternalModuleReference, expression: Expression): ExternalModuleReference;
createJSDocAllType(): JSDocAllType;
createJSDocUnknownType(): JSDocUnknownType;
createJSDocNonNullableType(type: TypeNode, postfix?: boolean): JSDocNonNullableType;
updateJSDocNonNullableType(node: JSDocNonNullableType, type: TypeNode): JSDocNonNullableType;
createJSDocNullableType(type: TypeNode, postfix?: boolean): JSDocNullableType;
updateJSDocNullableType(node: JSDocNullableType, type: TypeNode): JSDocNullableType;
createJSDocOptionalType(type: TypeNode): JSDocOptionalType;
updateJSDocOptionalType(node: JSDocOptionalType, type: TypeNode): JSDocOptionalType;
createJSDocFunctionType(parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): JSDocFunctionType;
updateJSDocFunctionType(node: JSDocFunctionType, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): JSDocFunctionType;
createJSDocVariadicType(type: TypeNode): JSDocVariadicType;
updateJSDocVariadicType(node: JSDocVariadicType, type: TypeNode): JSDocVariadicType;
createJSDocNamepathType(type: TypeNode): JSDocNamepathType;
updateJSDocNamepathType(node: JSDocNamepathType, type: TypeNode): JSDocNamepathType;
createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression;
updateJSDocTypeExpression(node: JSDocTypeExpression, type: TypeNode): JSDocTypeExpression;
createJSDocNameReference(name: EntityName | JSDocMemberName): JSDocNameReference;
updateJSDocNameReference(node: JSDocNameReference, name: EntityName | JSDocMemberName): JSDocNameReference;
createJSDocMemberName(left: EntityName | JSDocMemberName, right: Identifier): JSDocMemberName;
updateJSDocMemberName(node: JSDocMemberName, left: EntityName | JSDocMemberName, right: Identifier): JSDocMemberName;
createJSDocLink(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink;
updateJSDocLink(node: JSDocLink, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink;
createJSDocLinkCode(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode;
updateJSDocLinkCode(node: JSDocLinkCode, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode;
createJSDocLinkPlain(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain;
updateJSDocLinkPlain(node: JSDocLinkPlain, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain;
createJSDocTypeLiteral(jsDocPropertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral;
updateJSDocTypeLiteral(node: JSDocTypeLiteral, jsDocPropertyTags: readonly JSDocPropertyLikeTag[] | undefined, isArrayType: boolean | undefined): JSDocTypeLiteral;
createJSDocSignature(typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag): JSDocSignature;
updateJSDocSignature(node: JSDocSignature, typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type: JSDocReturnTag | undefined): JSDocSignature;
createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray): JSDocTemplateTag;
updateJSDocTemplateTag(node: JSDocTemplateTag, tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment: string | NodeArray | undefined): JSDocTemplateTag;
createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | JSDocTypeLiteral, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string | NodeArray): JSDocTypedefTag;
updateJSDocTypedefTag(node: JSDocTypedefTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | JSDocTypeLiteral | undefined, fullName: Identifier | JSDocNamespaceDeclaration | undefined, comment: string | NodeArray | undefined): JSDocTypedefTag;
createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray): JSDocParameterTag;
updateJSDocParameterTag(node: JSDocParameterTag, tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression: JSDocTypeExpression | undefined, isNameFirst: boolean, comment: string | NodeArray | undefined): JSDocParameterTag;
createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray): JSDocPropertyTag;
updateJSDocPropertyTag(node: JSDocPropertyTag, tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression: JSDocTypeExpression | undefined, isNameFirst: boolean, comment: string | NodeArray | undefined): JSDocPropertyTag;
createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray): JSDocTypeTag;
updateJSDocTypeTag(node: JSDocTypeTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment: string | NodeArray | undefined): JSDocTypeTag;
createJSDocSeeTag(tagName: Identifier | undefined, nameExpression: JSDocNameReference | undefined, comment?: string | NodeArray): JSDocSeeTag;
updateJSDocSeeTag(node: JSDocSeeTag, tagName: Identifier | undefined, nameExpression: JSDocNameReference | undefined, comment?: string | NodeArray): JSDocSeeTag;
createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string | NodeArray): JSDocReturnTag;
updateJSDocReturnTag(node: JSDocReturnTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | undefined, comment: string | NodeArray | undefined): JSDocReturnTag;
createJSDocThisTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray): JSDocThisTag;
updateJSDocThisTag(node: JSDocThisTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | undefined, comment: string | NodeArray | undefined): JSDocThisTag;
createJSDocEnumTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray): JSDocEnumTag;
updateJSDocEnumTag(node: JSDocEnumTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment: string | NodeArray | undefined): JSDocEnumTag;
createJSDocCallbackTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string | NodeArray): JSDocCallbackTag;
updateJSDocCallbackTag(node: JSDocCallbackTag, tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName: Identifier | JSDocNamespaceDeclaration | undefined, comment: string | NodeArray | undefined): JSDocCallbackTag;
createJSDocOverloadTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, comment?: string | NodeArray): JSDocOverloadTag;
updateJSDocOverloadTag(node: JSDocOverloadTag, tagName: Identifier | undefined, typeExpression: JSDocSignature, comment: string | NodeArray | undefined): JSDocOverloadTag;
createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment?: string | NodeArray): JSDocAugmentsTag;
updateJSDocAugmentsTag(node: JSDocAugmentsTag, tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment: string | NodeArray | undefined): JSDocAugmentsTag;
createJSDocImplementsTag(tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment?: string | NodeArray): JSDocImplementsTag;
updateJSDocImplementsTag(node: JSDocImplementsTag, tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment: string | NodeArray | undefined): JSDocImplementsTag;
createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string | NodeArray