/// <reference path="../../src/server/types.d.ts" />

declare namespace ts.server.protocol {

namespace CommandTypes {

type Brace = "brace";

type BraceFull = "brace-full";

type BraceCompletion = "braceCompletion";

type Change = "change";

type Close = "close";

type Completions = "completions";

type CompletionsFull = "completions-full";

type CompletionDetails = "completionEntryDetails";

type CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList";

type CompileOnSaveEmitFile = "compileOnSaveEmitFile";

type Configure = "configure";

type Definition = "definition";

type DefinitionFull = "definition-full";

type Implementation = "implementation";

type ImplementationFull = "implementation-full";

type Exit = "exit";

type Format = "format";

type Formatonkey = "formatonkey";

type FormatFull = "format-full";

type FormatonkeyFull = "formatonkey-full";

type FormatRangeFull = "formatRange-full";

type Geterr = "geterr";

type GeterrForProject = "geterrForProject";

type SemanticDiagnosticsSync = "semanticDiagnosticsSync";

type SyntacticDiagnosticsSync = "syntacticDiagnosticsSync";

type NavBar = "navbar";

type NavBarFull = "navbar-full";

type Navto = "navto";

type NavtoFull = "navto-full";

type NavTree = "navtree";

type NavTreeFull = "navtree-full";

type Occurrences = "occurrences";

type DocumentHighlights = "documentHighlights";

type DocumentHighlightsFull = "documentHighlights-full";

type Open = "open";

type Quickinfo = "quickinfo";

type QuickinfoFull = "quickinfo-full";

type References = "references";

type ReferencesFull = "references-full";

type Reload = "reload";

type Rename = "rename";

type RenameInfoFull = "rename-full";

type RenameLocationsFull = "renameLocations-full";

type Saveto = "saveto";

type SignatureHelp = "signatureHelp";

type SignatureHelpFull = "signatureHelp-full";

type TypeDefinition = "typeDefinition";

type ProjectInfo = "projectInfo";

type ReloadProjects = "reloadProjects";

type Unknown = "unknown";

type OpenExternalProject = "openExternalProject";

type OpenExternalProjects = "openExternalProjects";

type CloseExternalProject = "closeExternalProject";

type SynchronizeProjectList = "synchronizeProjectList";

type ApplyChangedToOpenFiles = "applyChangedToOpenFiles";

type EncodedSemanticClassificationsFull = "encodedSemanticClassifications-full";

type Cleanup = "cleanup";

type OutliningSpans = "outliningSpans";

type TodoComments = "todoComments";

type Indentation = "indentation";

type DocCommentTemplate = "docCommentTemplate";

type CompilerOptionsDiagnosticsFull = "compilerOptionsDiagnostics-full";

type NameOrDottedNameSpan = "nameOrDottedNameSpan";

type BreakpointStatement = "breakpointStatement";

type CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects";

type GetCodeFixes = "getCodeFixes";

type GetCodeFixesFull = "getCodeFixes-full";

type GetSupportedCodeFixes = "getSupportedCodeFixes";

}

interface Message {

seq: number;

type: "request" | "response" | "event";

}

interface Request extends Message {

command: string;

arguments?: any;

}

interface ReloadProjectsRequest extends Message {

command: CommandTypes.ReloadProjects;

}

interface Event extends Message {

event: string;

body?: any;

}

interface Response extends Message {

request_seq: number;

success: boolean;

command: string;

message?: string;

body?: any;

}

interface FileRequestArgs {

file: string;

projectFileName?: string;

}

interface DocCommentTemplateRequest extends FileLocationRequest {

command: CommandTypes.DocCommentTemplate;

}

interface DocCommandTemplateResponse extends Response {

body?: TextInsertion;

}

interface TodoCommentRequest extends FileRequest {

command: CommandTypes.TodoComments;

arguments: TodoCommentRequestArgs;

}

interface TodoCommentRequestArgs extends FileRequestArgs {

descriptors: TodoCommentDescriptor[];

}

interface TodoCommentsResponse extends Response {

body?: TodoComment[];

}

interface OutliningSpansRequest extends FileRequest {

command: CommandTypes.OutliningSpans;

}

interface OutliningSpansResponse extends Response {

body?: OutliningSpan[];

}

interface IndentationRequest extends FileLocationRequest {

command: CommandTypes.Indentation;

arguments: IndentationRequestArgs;

}

interface IndentationResponse extends Response {

body?: IndentationResult;

}

interface IndentationResult {

position: number;

indentation: number;

}

interface IndentationRequestArgs extends FileLocationRequestArgs {

options?: EditorSettings;

}

interface ProjectInfoRequestArgs extends FileRequestArgs {

needFileNameList: boolean;

}

interface ProjectInfoRequest extends Request {

command: CommandTypes.ProjectInfo;

arguments: ProjectInfoRequestArgs;

}

interface CompilerOptionsDiagnosticsRequest extends Request {

arguments: CompilerOptionsDiagnosticsRequestArgs;

}

interface CompilerOptionsDiagnosticsRequestArgs {

projectFileName: string;

}

interface ProjectInfo {

configFileName: string;

fileNames?: string[];

languageServiceDisabled?: boolean;

}

interface DiagnosticWithLinePosition {

message: string;

start: number;

length: number;

startLocation: Location;

endLocation: Location;

category: string;

code: number;

}

interface ProjectInfoResponse extends Response {

body?: ProjectInfo;

}

interface FileRequest extends Request {

arguments: FileRequestArgs;

}

interface FileLocationRequestArgs extends FileRequestArgs {

line: number;

offset: number;

position?: number;

}

interface CodeFixRequest extends Request {

command: CommandTypes.GetCodeFixes;

arguments: CodeFixRequestArgs;

}

interface CodeFixRequestArgs extends FileRequestArgs {

startLine: number;

startOffset: number;

startPosition?: number;

endLine: number;

endOffset: number;

endPosition?: number;

errorCodes?: number[];

}

interface GetCodeFixesResponse extends Response {

body?: CodeAction[];

}

interface FileLocationRequest extends FileRequest {

arguments: FileLocationRequestArgs;

}

interface GetSupportedCodeFixesRequest extends Request {

command: CommandTypes.GetSupportedCodeFixes;

}

interface GetSupportedCodeFixesResponse extends Response {

body?: string[];

}

interface EncodedSemanticClassificationsRequest extends FileRequest {

arguments: EncodedSemanticClassificationsRequestArgs;

}

interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs {

start: number;

length: number;

}

interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs {

filesToSearch: string[];

}

interface DefinitionRequest extends FileLocationRequest {

command: CommandTypes.Definition;

}

interface TypeDefinitionRequest extends FileLocationRequest {

command: CommandTypes.TypeDefinition;

}

interface ImplementationRequest extends FileLocationRequest {

command: CommandTypes.Implementation;

}

interface Location {

line: number;

offset: number;

}

interface TextSpan {

start: Location;

end: Location;

}

interface FileSpan extends TextSpan {

file: string;

}

interface DefinitionResponse extends Response {

body?: FileSpan[];

}

interface TypeDefinitionResponse extends Response {

body?: FileSpan[];

}

interface ImplementationResponse extends Response {

body?: FileSpan[];

}

interface BraceCompletionRequest extends FileLocationRequest {

command: CommandTypes.BraceCompletion;

arguments: BraceCompletionRequestArgs;

}

interface BraceCompletionRequestArgs extends FileLocationRequestArgs {

openingBrace: string;

}

interface OccurrencesRequest extends FileLocationRequest {

command: CommandTypes.Occurrences;

}

interface OccurrencesResponseItem extends FileSpan {

isWriteAccess: boolean;

}

interface OccurrencesResponse extends Response {

body?: OccurrencesResponseItem[];

}

interface DocumentHighlightsRequest extends FileLocationRequest {

command: CommandTypes.DocumentHighlights;

arguments: DocumentHighlightsRequestArgs;

}

interface HighlightSpan extends TextSpan {

kind: string;

}

interface DocumentHighlightsItem {

file: string;

highlightSpans: HighlightSpan[];

}

interface DocumentHighlightsResponse extends Response {

body?: DocumentHighlightsItem[];

}

interface ReferencesRequest extends FileLocationRequest {

command: CommandTypes.References;

}

interface ReferencesResponseItem extends FileSpan {

lineText: string;

isWriteAccess: boolean;

isDefinition: boolean;

}

interface ReferencesResponseBody {

refs: ReferencesResponseItem[];

symbolName: string;

symbolStartOffset: number;

symbolDisplayString: string;

}

interface ReferencesResponse extends Response {

body?: ReferencesResponseBody;

}

interface RenameRequestArgs extends FileLocationRequestArgs {

findInComments?: boolean;

findInStrings?: boolean;

}

interface RenameRequest extends FileLocationRequest {

command: CommandTypes.Rename;

arguments: RenameRequestArgs;

}

interface RenameInfo {

canRename: boolean;

localizedErrorMessage?: string;

displayName: string;

fullDisplayName: string;

kind: string;

kindModifiers: string;

}

interface SpanGroup {

file: string;

locs: TextSpan[];

}

interface RenameResponseBody {

info: RenameInfo;

locs: SpanGroup[];

}

interface RenameResponse extends Response {

body?: RenameResponseBody;

}

interface ExternalFile {

fileName: string;

scriptKind?: ScriptKindName | ts.ScriptKind;

hasMixedContent?: boolean;

content?: string;

}

interface ExternalProject {

projectFileName: string;

rootFiles: ExternalFile[];

options: ExternalProjectCompilerOptions;

typingOptions?: TypeAcquisition;

typeAcquisition?: TypeAcquisition;

}

interface CompileOnSaveMixin {

compileOnSave?: boolean;

}

type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin;

interface ProjectVersionInfo {

projectName: string;

isInferred: boolean;

version: number;

options: ts.CompilerOptions;

languageServiceDisabled: boolean;

}

interface ProjectChanges {

added: string[];

removed: string[];

updated: string[];

}

interface ProjectFiles {

info?: ProjectVersionInfo;

files?: string[];

changes?: ProjectChanges;

}

interface ProjectFilesWithDiagnostics extends ProjectFiles {

projectErrors: DiagnosticWithLinePosition[];

}

interface ChangedOpenFile {

fileName: string;

changes: ts.TextChange[];

}

interface ConfigureRequestArguments {

hostInfo?: string;

file?: string;

formatOptions?: FormatCodeSettings;

extraFileExtensions?: FileExtensionInfo[];

}

interface ConfigureRequest extends Request {

command: CommandTypes.Configure;

arguments: ConfigureRequestArguments;

}

interface ConfigureResponse extends Response {

}

interface OpenRequestArgs extends FileRequestArgs {

fileContent?: string;

scriptKindName?: ScriptKindName;

}

type ScriptKindName = "TS" | "JS" | "TSX" | "JSX";

interface OpenRequest extends Request {

command: CommandTypes.Open;

arguments: OpenRequestArgs;

}

interface OpenExternalProjectRequest extends Request {

command: CommandTypes.OpenExternalProject;

arguments: OpenExternalProjectArgs;

}

type OpenExternalProjectArgs = ExternalProject;

interface OpenExternalProjectsRequest extends Request {

command: CommandTypes.OpenExternalProjects;

arguments: OpenExternalProjectsArgs;

}

interface OpenExternalProjectsArgs {

projects: ExternalProject[];

}

interface OpenExternalProjectResponse extends Response {

}

interface OpenExternalProjectsResponse extends Response {

}

interface CloseExternalProjectRequest extends Request {

command: CommandTypes.CloseExternalProject;

arguments: CloseExternalProjectRequestArgs;

}

interface CloseExternalProjectRequestArgs {

projectFileName: string;

}

interface CloseExternalProjectResponse extends Response {

}

interface SynchronizeProjectListRequest extends Request {

arguments: SynchronizeProjectListRequestArgs;

}

interface SynchronizeProjectListRequestArgs {

knownProjects: protocol.ProjectVersionInfo[];

}

interface ApplyChangedToOpenFilesRequest extends Request {

arguments: ApplyChangedToOpenFilesRequestArgs;

}

interface ApplyChangedToOpenFilesRequestArgs {

openFiles?: ExternalFile[];

changedFiles?: ChangedOpenFile[];

closedFiles?: string[];

}

interface SetCompilerOptionsForInferredProjectsRequest extends Request {

command: CommandTypes.CompilerOptionsForInferredProjects;

arguments: SetCompilerOptionsForInferredProjectsArgs;

}

interface SetCompilerOptionsForInferredProjectsArgs {

options: ExternalProjectCompilerOptions;

}

interface SetCompilerOptionsForInferredProjectsResponse extends Response {

}

interface ExitRequest extends Request {

command: CommandTypes.Exit;

}

interface CloseRequest extends FileRequest {

command: CommandTypes.Close;

}

interface CompileOnSaveAffectedFileListRequest extends FileRequest {

command: CommandTypes.CompileOnSaveAffectedFileList;

}

interface CompileOnSaveAffectedFileListSingleProject {

projectFileName: string;

fileNames: string[];

}

interface CompileOnSaveAffectedFileListResponse extends Response {

body: CompileOnSaveAffectedFileListSingleProject[];

}

interface CompileOnSaveEmitFileRequest extends FileRequest {

command: CommandTypes.CompileOnSaveEmitFile;

arguments: CompileOnSaveEmitFileRequestArgs;

}

interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs {

forced?: boolean;

}

interface QuickInfoRequest extends FileLocationRequest {

command: CommandTypes.Quickinfo;

}

interface QuickInfoResponseBody {

kind: string;

kindModifiers: string;

start: Location;

end: Location;

displayString: string;

documentation: string;

}

interface QuickInfoResponse extends Response {

body?: QuickInfoResponseBody;

}

interface FormatRequestArgs extends FileLocationRequestArgs {

endLine: number;

endOffset: number;

endPosition?: number;

options?: FormatCodeSettings;

}

interface FormatRequest extends FileLocationRequest {

command: CommandTypes.Format;

arguments: FormatRequestArgs;

}

interface CodeEdit {

start: Location;

end: Location;

newText: string;

}

interface FileCodeEdits {

fileName: string;

textChanges: CodeEdit[];

}

interface CodeFixResponse extends Response {

body?: CodeAction[];

}

interface CodeAction {

description: string;

changes: FileCodeEdits[];

}

interface FormatResponse extends Response {

body?: CodeEdit[];

}

interface FormatOnKeyRequestArgs extends FileLocationRequestArgs {

key: string;

options?: FormatCodeSettings;

}

interface FormatOnKeyRequest extends FileLocationRequest {

command: CommandTypes.Formatonkey;

arguments: FormatOnKeyRequestArgs;

}

interface CompletionsRequestArgs extends FileLocationRequestArgs {

prefix?: string;

}

interface CompletionsRequest extends FileLocationRequest {

command: CommandTypes.Completions;

arguments: CompletionsRequestArgs;

}

interface CompletionDetailsRequestArgs extends FileLocationRequestArgs {

entryNames: string[];

}

interface CompletionDetailsRequest extends FileLocationRequest {

command: CommandTypes.CompletionDetails;

arguments: CompletionDetailsRequestArgs;

}

interface SymbolDisplayPart {

text: string;

kind: string;

}

interface CompletionEntry {

name: string;

kind: string;

kindModifiers: string;

sortText: string;

replacementSpan?: TextSpan;

}

interface CompletionEntryDetails {

name: string;

kind: string;

kindModifiers: string;

displayParts: SymbolDisplayPart[];

documentation: SymbolDisplayPart[];

}

interface CompletionsResponse extends Response {

body?: CompletionEntry[];

}

interface CompletionDetailsResponse extends Response {

body?: CompletionEntryDetails[];

}

interface SignatureHelpParameter {

name: string;

documentation: SymbolDisplayPart[];

displayParts: SymbolDisplayPart[];

isOptional: boolean;

}

interface SignatureHelpItem {

isVariadic: boolean;

prefixDisplayParts: SymbolDisplayPart[];

suffixDisplayParts: SymbolDisplayPart[];

separatorDisplayParts: SymbolDisplayPart[];

parameters: SignatureHelpParameter[];

documentation: SymbolDisplayPart[];

}

interface SignatureHelpItems {

items: SignatureHelpItem[];

applicableSpan: TextSpan;

selectedItemIndex: number;

argumentIndex: number;

argumentCount: number;

}

interface SignatureHelpRequestArgs extends FileLocationRequestArgs {

}

interface SignatureHelpRequest extends FileLocationRequest {

command: CommandTypes.SignatureHelp;

arguments: SignatureHelpRequestArgs;

}

interface SignatureHelpResponse extends Response {

body?: SignatureHelpItems;

}

interface SemanticDiagnosticsSyncRequest extends FileRequest {

command: CommandTypes.SemanticDiagnosticsSync;

arguments: SemanticDiagnosticsSyncRequestArgs;

}

interface SemanticDiagnosticsSyncRequestArgs extends FileRequestArgs {

includeLinePosition?: boolean;

}

interface SemanticDiagnosticsSyncResponse extends Response {

body?: Diagnostic[] | DiagnosticWithLinePosition[];

}

interface SyntacticDiagnosticsSyncRequest extends FileRequest {

command: CommandTypes.SyntacticDiagnosticsSync;

arguments: SyntacticDiagnosticsSyncRequestArgs;

}

interface SyntacticDiagnosticsSyncRequestArgs extends FileRequestArgs {

includeLinePosition?: boolean;

}

interface SyntacticDiagnosticsSyncResponse extends Response {

body?: Diagnostic[] | DiagnosticWithLinePosition[];

}

interface GeterrForProjectRequestArgs {

file: string;

delay: number;

}

interface GeterrForProjectRequest extends Request {

command: CommandTypes.GeterrForProject;

arguments: GeterrForProjectRequestArgs;

}

interface GeterrRequestArgs {

files: string[];

delay: number;

}

interface GeterrRequest extends Request {

command: CommandTypes.Geterr;

arguments: GeterrRequestArgs;

}

interface Diagnostic {

start: Location;

end: Location;

text: string;

code?: number;

}

interface DiagnosticEventBody {

file: string;

diagnostics: Diagnostic[];

}

interface DiagnosticEvent extends Event {

body?: DiagnosticEventBody;

}

interface ConfigFileDiagnosticEventBody {

triggerFile: string;

configFile: string;

diagnostics: Diagnostic[];

}

interface ConfigFileDiagnosticEvent extends Event {

body?: ConfigFileDiagnosticEventBody;

event: "configFileDiag";

}

type ProjectLanguageServiceStateEventName = "projectLanguageServiceState";

interface ProjectLanguageServiceStateEvent extends Event {

event: ProjectLanguageServiceStateEventName;

body?: ProjectLanguageServiceStateEventBody;

}

interface ProjectLanguageServiceStateEventBody {

projectName: string;

languageServiceEnabled: boolean;

}

interface ReloadRequestArgs extends FileRequestArgs {

tmpfile: string;

}

interface ReloadRequest extends FileRequest {

command: CommandTypes.Reload;

arguments: ReloadRequestArgs;

}

interface ReloadResponse extends Response {

}

interface SavetoRequestArgs extends FileRequestArgs {

tmpfile: string;

}

interface SavetoRequest extends FileRequest {

command: CommandTypes.Saveto;

arguments: SavetoRequestArgs;

}

interface NavtoRequestArgs extends FileRequestArgs {

searchValue: string;

maxResultCount?: number;

currentFileOnly?: boolean;

projectFileName?: string;

}

interface NavtoRequest extends FileRequest {

command: CommandTypes.Navto;

arguments: NavtoRequestArgs;

}

interface NavtoItem {

name: string;

kind: string;

matchKind?: string;

isCaseSensitive?: boolean;

kindModifiers?: string;

file: string;

start: Location;

end: Location;

containerName?: string;

containerKind?: string;

}

interface NavtoResponse extends Response {

body?: NavtoItem[];

}

interface ChangeRequestArgs extends FormatRequestArgs {

insertString?: string;

}

interface ChangeRequest extends FileLocationRequest {

command: CommandTypes.Change;

arguments: ChangeRequestArgs;

}

interface BraceResponse extends Response {

body?: TextSpan[];

}

interface BraceRequest extends FileLocationRequest {

command: CommandTypes.Brace;

}

interface NavBarRequest extends FileRequest {

command: CommandTypes.NavBar;

}

interface NavTreeRequest extends FileRequest {

command: CommandTypes.NavTree;

}

interface NavigationBarItem {

text: string;

kind: string;

kindModifiers?: string;

spans: TextSpan[];

childItems?: NavigationBarItem[];

indent: number;

}

interface NavigationTree {

text: string;

kind: string;

kindModifiers: string;

spans: TextSpan[];

childItems?: NavigationTree[];

}

type TelemetryEventName = "telemetry";

interface TelemetryEvent extends Event {

event: TelemetryEventName;

body: TelemetryEventBody;

}

interface TelemetryEventBody {

telemetryEventName: string;

payload: any;

}

type TypingsInstalledTelemetryEventName = "typingsInstalled";

interface TypingsInstalledTelemetryEventBody extends TelemetryEventBody {

telemetryEventName: TypingsInstalledTelemetryEventName;

payload: TypingsInstalledTelemetryEventPayload;

}

interface TypingsInstalledTelemetryEventPayload {

installedPackages: string;

installSuccess: boolean;

typingsInstallerVersion: string;

}

type BeginInstallTypesEventName = "beginInstallTypes";

type EndInstallTypesEventName = "endInstallTypes";

interface BeginInstallTypesEvent extends Event {

event: BeginInstallTypesEventName;

body: BeginInstallTypesEventBody;

}

interface EndInstallTypesEvent extends Event {

event: EndInstallTypesEventName;

body: EndInstallTypesEventBody;

}

interface InstallTypesEventBody {

eventId: number;

packages: ReadonlyArray<string>;

}

interface BeginInstallTypesEventBody extends InstallTypesEventBody {

}

interface EndInstallTypesEventBody extends InstallTypesEventBody {

success: boolean;

}

interface NavBarResponse extends Response {

body?: NavigationBarItem[];

}

interface NavTreeResponse extends Response {

body?: NavigationTree;

}

namespace IndentStyle {

type None = "None";

type Block = "Block";

type Smart = "Smart";

}

type IndentStyle = IndentStyle.None | IndentStyle.Block | IndentStyle.Smart;

interface EditorSettings {

baseIndentSize?: number;

indentSize?: number;

tabSize?: number;

newLineCharacter?: string;

convertTabsToSpaces?: boolean;

indentStyle?: IndentStyle | ts.IndentStyle;

}

interface FormatCodeSettings extends EditorSettings {

insertSpaceAfterCommaDelimiter?: boolean;

insertSpaceAfterSemicolonInForStatements?: boolean;

insertSpaceBeforeAndAfterBinaryOperators?: boolean;

insertSpaceAfterKeywordsInControlFlowStatements?: boolean;

insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;

insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;

insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;

insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;

insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;

placeOpenBraceOnNewLineForFunctions?: boolean;

placeOpenBraceOnNewLineForControlBlocks?: boolean;

}

interface CompilerOptions {

allowJs?: boolean;

allowSyntheticDefaultImports?: boolean;

allowUnreachableCode?: boolean;

allowUnusedLabels?: boolean;

baseUrl?: string;

charset?: string;

declaration?: boolean;

declarationDir?: string;

disableSizeLimit?: boolean;

emitBOM?: boolean;

emitDecoratorMetadata?: boolean;

experimentalDecorators?: boolean;

forceConsistentCasingInFileNames?: boolean;

inlineSourceMap?: boolean;

inlineSources?: boolean;

isolatedModules?: boolean;

jsx?: JsxEmit | ts.JsxEmit;

lib?: string[];

locale?: string;

mapRoot?: string;

maxNodeModuleJsDepth?: number;

module?: ModuleKind | ts.ModuleKind;

moduleResolution?: ModuleResolutionKind | ts.ModuleResolutionKind;

newLine?: NewLineKind | ts.NewLineKind;

noEmit?: boolean;

noEmitHelpers?: boolean;

noEmitOnError?: boolean;

noErrorTruncation?: boolean;

noFallthroughCasesInSwitch?: boolean;

noImplicitAny?: boolean;

noImplicitReturns?: boolean;

noImplicitThis?: boolean;

noUnusedLocals?: boolean;

noUnusedParameters?: boolean;

noImplicitUseStrict?: boolean;

noLib?: boolean;

noResolve?: boolean;

out?: string;

outDir?: string;

outFile?: string;

paths?: MapLike<string[]>;

preserveConstEnums?: boolean;

project?: string;

reactNamespace?: string;

removeComments?: boolean;

rootDir?: string;

rootDirs?: string[];

skipLibCheck?: boolean;

skipDefaultLibCheck?: boolean;

sourceMap?: boolean;

sourceRoot?: string;

strictNullChecks?: boolean;

suppressExcessPropertyErrors?: boolean;

suppressImplicitAnyIndexErrors?: boolean;

target?: ScriptTarget | ts.ScriptTarget;

traceResolution?: boolean;

types?: string[];

typeRoots?: string[];

[option: string]: CompilerOptionsValue | undefined;

}

namespace JsxEmit {

type None = "None";

type Preserve = "Preserve";

type React = "React";

}

type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;

namespace ModuleKind {

type None = "None";

type CommonJS = "CommonJS";

type AMD = "AMD";

type UMD = "UMD";

type System = "System";

type ES6 = "ES6";

type ES2015 = "ES2015";

}

type ModuleKind = ModuleKind.None | ModuleKind.CommonJS | ModuleKind.AMD | ModuleKind.UMD | ModuleKind.System | ModuleKind.ES6 | ModuleKind.ES2015;

namespace ModuleResolutionKind {

type Classic = "Classic";

type Node = "Node";

}

type ModuleResolutionKind = ModuleResolutionKind.Classic | ModuleResolutionKind.Node;

namespace NewLineKind {

type Crlf = "Crlf";

type Lf = "Lf";

}

type NewLineKind = NewLineKind.Crlf | NewLineKind.Lf;

namespace ScriptTarget {

type ES3 = "ES3";

type ES5 = "ES5";

type ES6 = "ES6";

type ES2015 = "ES2015";

}

type ScriptTarget = ScriptTarget.ES3 | ScriptTarget.ES5 | ScriptTarget.ES6 | ScriptTarget.ES2015;

}

declare namespace ts {

interface MapLike<T> {

[index: string]: T;

}

interface Map<T> extends MapLike<T> {

__mapBrand: any;

}

type Path = string & {

__pathBrand: any;

};

interface FileMap<T> {

get(fileName: Path): T;

set(fileName: Path, value: T): void;

contains(fileName: Path): boolean;

remove(fileName: Path): void;

forEachValue(f: (key: Path, v: T) => void): void;

getKeys(): Path[];

clear(): void;

}

interface TextRange {

pos: number;

end: number;

}

const enum SyntaxKind {

Unknown = 0,

EndOfFileToken = 1,

SingleLineCommentTrivia = 2,

MultiLineCommentTrivia = 3,

NewLineTrivia = 4,

WhitespaceTrivia = 5,

ShebangTrivia = 6,

ConflictMarkerTrivia = 7,

NumericLiteral = 8,

StringLiteral = 9,

JsxText = 10,

RegularExpressionLiteral = 11,

NoSubstitutionTemplateLiteral = 12,

TemplateHead = 13,

TemplateMiddle = 14,

TemplateTail = 15,

OpenBraceToken = 16,

CloseBraceToken = 17,

OpenParenToken = 18,

CloseParenToken = 19,

OpenBracketToken = 20,

CloseBracketToken = 21,

DotToken = 22,

DotDotDotToken = 23,

SemicolonToken = 24,

CommaToken = 25,

LessThanToken = 26,

LessThanSlashToken = 27,

GreaterThanToken = 28,

LessThanEqualsToken = 29,

GreaterThanEqualsToken = 30,

EqualsEqualsToken = 31,

ExclamationEqualsToken = 32,

EqualsEqualsEqualsToken = 33,

ExclamationEqualsEqualsToken = 34,

EqualsGreaterThanToken = 35,

PlusToken = 36,

MinusToken = 37,

AsteriskToken = 38,

AsteriskAsteriskToken = 39,

SlashToken = 40,

PercentToken = 41,

PlusPlusToken = 42,

MinusMinusToken = 43,

LessThanLessThanToken = 44,

GreaterThanGreaterThanToken = 45,

GreaterThanGreaterThanGreaterThanToken = 46,

AmpersandToken = 47,

BarToken = 48,

CaretToken = 49,

ExclamationToken = 50,

TildeToken = 51,

AmpersandAmpersandToken = 52,

BarBarToken = 53,

QuestionToken = 54,

ColonToken = 55,

AtToken = 56,

EqualsToken = 57,

PlusEqualsToken = 58,

MinusEqualsToken = 59,

AsteriskEqualsToken = 60,

AsteriskAsteriskEqualsToken = 61,

SlashEqualsToken = 62,

PercentEqualsToken = 63,

LessThanLessThanEqualsToken = 64,

GreaterThanGreaterThanEqualsToken = 65,

GreaterThanGreaterThanGreaterThanEqualsToken = 66,

AmpersandEqualsToken = 67,

BarEqualsToken = 68,

CaretEqualsToken = 69,

Identifier = 70,

BreakKeyword = 71,

CaseKeyword = 72,

CatchKeyword = 73,

ClassKeyword = 74,

ConstKeyword = 75,

ContinueKeyword = 76,

DebuggerKeyword = 77,

DefaultKeyword = 78,

DeleteKeyword = 79,

DoKeyword = 80,

ElseKeyword = 81,

EnumKeyword = 82,

ExportKeyword = 83,

ExtendsKeyword = 84,

FalseKeyword = 85,

FinallyKeyword = 86,

ForKeyword = 87,

FunctionKeyword = 88,

IfKeyword = 89,

ImportKeyword = 90,

InKeyword = 91,

InstanceOfKeyword = 92,

NewKeyword = 93,

NullKeyword = 94,

ReturnKeyword = 95,

SuperKeyword = 96,

SwitchKeyword = 97,

ThisKeyword = 98,

ThrowKeyword = 99,

TrueKeyword = 100,

TryKeyword = 101,

TypeOfKeyword = 102,

VarKeyword = 103,

VoidKeyword = 104,

WhileKeyword = 105,