TypeScript reference

No longer supported. In early versions, manually set the text encoding for reading files.

Specify emit/checking behavior for imports that are only used for types.

Make keyof only return strings instead of string, numbers or symbols. Legacy option.

Disable adding 'use strict' directives in emitted JavaScript files.

Disable strict checking of generic signatures in function types.

Deprecated setting. Use 'outFile' instead.

Preserve unused imported values in the JavaScript output that would otherwise be removed.

Disable reporting of excess property errors during the creation of object literals.

Suppress 'noImplicitAny' errors when indexing objects that lack index signatures.

A base class that cannot be instantiated and may declare abstract members subclasses must implement.

Controls compile-time visibility. ECMAScript #private fields provide real runtime privacy.

A constructor with typed fields, methods and access modifiers.

Describes types for untyped JavaScript or global APIs in a .d.ts file.

Checks that a class satisfies an interface without inheriting an implementation.

Imports all named exports as a single object.

A field that cannot be reassigned after construction.

Imports only types so the statement is erased and never creates a runtime dependency.

Show all compiler options.

Print this message.

Initializes a TypeScript project and creates a tsconfig.json file.

Print names of files that are part of the compilation and then stop processing.

Set the language of the messaging from TypeScript. This does not affect emit.

Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'.

Print the final configuration instead of building.

Print the compiler's version.

Watch input files.

Separates a missing property from a present property whose value is undefined. Stricter and more accurate.

Selects which files the project type-checks.

Declares the built-in APIs available. Without DOM, document and window are unknown to the compiler.

Matches how the runtime resolves imports. Use bundler for Vite, Nuxt and webpack.

Type-checks without writing files, because the bundler handles output.

Adds undefined to index access, forcing you to handle missing keys and holes.

Rewrites import paths for the compiler and editor. Your bundler must use the same aliases.

Skips type-checking declaration files, which speeds builds but can hide dependency conflicts.

Turns on the strict family, including strictNullChecks and noImplicitAny. Enable it on every new project.

Selects the JavaScript version emitted. Modern targets ship smaller output and rely on evergreen browsers.

Output compiler performance information after building.

Print files read during the compilation including why it was included.

Output more detailed compiler performance information after building.

Emit a v8 CPU profile of the compiler run for debugging.

Generates an event trace and a list of types.

Print the names of emitted files after a compilation.

Print all of the files read during the compilation.

Disable full type checking (only critical parse and emit errors will be reported).

Log paths used during the 'moduleResolution' process.

The ignoreDeprecations compiler option.

Skip type checking .d.ts files that are included with TypeScript.

Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server.

Specify a list of language service plugins to include.

Generate .d.ts files from TypeScript and JavaScript files in your project.

Specify the output directory for generated declaration files.

Create sourcemaps for d.ts files.

Emit more compliant, but verbose and less performant JavaScript for iteration.

Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files.

Only output d.ts files and not JavaScript files.

Allow importing helper functions from tslib once per project, instead of including them per-file.

Include sourcemap files inside the emitted JavaScript.

Include source code in the sourcemaps inside the emitted JavaScript.

Specify the location where debugger should locate map files instead of generated locations.

Set the newline character for emitting files.

Disable generating custom helper functions like '__extends' in compiled output.

Disable emitting files if any type checking errors are reported.

Specify an output folder for all emitted files.

Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output.

Disable erasing 'const enum' declarations in generated code.

Disable emitting comments.

Create source map files for emitted JavaScript files.

Specify the root path for debuggers to find the reference source code.

Disable emitting declarations that have '@internal' in their JSDoc comments.

Makes literals readonly and narrow instead of widening to string[].

Unwraps the value type of a promise, recursively.

Restricts a type parameter so the function can rely on certain members.

A type parameter makes a function work with many types while keeping the relationship between inputs and output.

Looks up the type of a property by key. Combine it with keyof for type-safe helpers.

The union of an object type’s property names. Useful for typed property access.

A tuple of a function’s parameter types.

Makes every property optional. Ideal for patch and update payloads.

Builds a new object type from selected or excluded keys.

Makes all top-level properties readonly. It is shallow, so nested objects stay mutable.

Maps a union of keys to a value type. All keys are required by default.

Makes every property required, the inverse of Partial.

Extracts the return type of a function type. Handy when you cannot import the type directly.

Checks a value against a type without widening it, so literal details are preserved.

Builds string types from patterns. Useful for event names and keys.

Allow 'import x from y' when a module doesn't have a default export.

Do not allow runtime constructs that are not part of ECMAScript.

Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility.

Ensure that casing is correct in imports.

Require sufficient annotation on exports so other tools can trivially generate declaration files.

Ensure that each file can be safely transpiled without relying on other imports.

Disable resolving symlinks to their realpath. This correlates to the same flag in node.

Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting.

Allow JavaScript files to be a part of your program. Use the 'checkJs' option to get errors from these files.

Enable error reporting in type-checked JavaScript files.

Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'.

Emit design-type metadata for decorated declarations in source files.

Enable experimental support for legacy experimental decorators.

Specify what JSX code is generated.

Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'.

Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'.

Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'.

Enable lib replacement.

Control what method is used to detect module-format JS files.

Disable including any library files, including the default lib.d.ts.

Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit.

Emit ECMAScript-standard-compliant class fields.

Enable importing files with any extension, provided a declaration file is present.

Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set.

Allow accessing UMD globals from modules.

Specify the base directory to resolve non-relative module names.

Conditions to set in addition to the resolver-specific defaults when resolving imports.

Specify what module code is generated.

List of file name suffixes to search when resolving a module.

Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project.

Check side effect imports.

Enable importing .json files.

Use the package.json 'exports' field when resolving package imports.

Use the package.json 'imports' field when resolving imports.

Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files.

Specify the root folder within your source files.

Allow multiple folders to be treated as one when resolving modules.

Specify multiple folders that act like './node_modules/@types'.

Specify type package names to be included without being referenced in a source file.

A function that throws when a condition fails and therefore narrows for the caller.

A shared literal field lets TypeScript narrow the whole object in a switch.

A never assignment in the default branch makes the compiler flag any unhandled union member.

Narrows by checking whether a property exists on the value.

Narrows to a class at runtime. Catch values are unknown because anything can be thrown.

Tells the compiler a value is not null. It performs no runtime check, so use it only when the fact is guaranteed.

Overrides inference. Prefer narrowing or validation; assertions can hide real bugs.

A user-defined guard that teaches TypeScript how a function narrows its argument.

Narrows primitives at runtime. TypeScript understands the guard in the same scope.

A value that may be one of several types. Narrow before calling type-specific methods.

Disable truncating types in error messages.

Disable wiping the console in watch mode.

Enable color and formatting in TypeScript's output to make compiler errors easier to read.

Enable constraints that allow a TypeScript project to be used with project references.

Reduce the number of projects loaded automatically by TypeScript.

Opt a project out of multi-project reference checking when editing.

Disable preferring source files instead of declaration files when referencing composite projects.

Save .tsbuildinfo files to allow for incremental compilation of projects.

Specify the path to .tsbuildinfo incremental compilation file.

Disable error reporting for unreachable code.

Disable error reporting for unused labels.

Ensure 'use strict' is always emitted.

Enable error reporting for fallthrough cases in switch statements.

Enable error reporting for expressions and declarations with an implied 'any' type.

Ensure overriding members in derived classes are marked with an override modifier.

Enable error reporting for codepaths that do not explicitly return in a function.

Enable error reporting when 'this' is given the type 'any'.

Enforces using indexed accessors for keys declared using an indexed type.

Enable error reporting when local variables aren't read.

Raise an error when a function parameter isn't read.

Check that the arguments for 'bind', 'call', and 'apply' methods match the original function.

Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'.

When assigning functions, check to ensure parameters and the return values are subtype-compatible.

When type checking, take into account 'null' and 'undefined'.

Check for class properties that are declared but not set in the constructor.

Default catch clause variables as 'unknown' instead of 'any'.

Disables type checking. Treat it as an escape hatch that should not cross module boundaries.

Declares an array of a single element type. Readonly<string[]> prevents mutation.

Named constants. Prefer union literals for new code because enums add runtime objects.

Describes a function signature, including parameters and return type.

Describes an object shape. Interfaces can be extended and declared twice; type aliases cannot.

Restricts a value to exact literals. Perfect for options, states and event names.

The type of a value that cannot happen, or of a function that never returns normally.

With strictNullChecks, null and undefined are separate types and must be handled explicitly.

The property may be missing or undefined. Do not use it for values that are always present but sometimes empty.

Prevents reassignment of the property after creation. It is shallow and checked only by the compiler.

An object whose keys and values share types.

A fixed-length array where each position has a type. Optional and rest elements are allowed.

Gives a name to any type, including unions and tuples. Aliases are erased at build time.

Declares the expected type of a value. Inference usually means you only annotate boundaries.

A safe alternative to any: you must narrow before using the value.

The return type for functions that do not return a value. A void callback may ignore any return value.

Have recompiles in projects that use 'incremental' and 'watch' mode assume that changes within a file will only affect files directly depending on it.