Import Attributes

Allows specifying attributes for imports

import jsonData from "./data.json" with { type: "json" };

const Contextual Keyword

Allows const in more contexts

const obj = { key: "value" } as const;

Decoupled Type and Function Parameter Lists

Allows separating types and function parameters

function foo<T>(x: T) {}

New decorators syntax

Updated decorator implementation

@sealed
class MyClass {}

Explicit Resource Management

Adds using for resource cleanup

using resource = new SomeResource();

Easier Implicit Returns for void Functions

No longer requires return for void functions

function logMessage(): void {
  console.log("Hello");
}

Enum Unions as Discriminants

Allows union types to be used in discriminated unions

type Shape = { kind: "circle", radius: number } | { kind: "square", side: number };

New decorators

Standardized decorator support

@sealed
class MyClass {}

satisfies Operator

Ensures type compatibility without altering type inference

const palette = {
  primary: "#ff0000",
} satisfies Record<string, string>;

Improved Inference for Object Methods

Better inference for method assignments

const obj = {
  method() {
    return "Hello";
  },
};

ECMAScript Module Support in Node.js

Enables native ESM support

import { readFile } from "fs/promises";

Control Flow Analysis for Destructured Variables

Improves type narrowing for destructuring

function process(obj: { x?: number }) {
  if (obj.x) {
    const { x } = obj;
    console.log(x.toFixed());
  }
}

Awaited Utility Type

Extracts the resolved type from a promise

type Data = Awaited<Promise<string>>;

Exact Optional Property Types

Optional properties no longer allow undefined implicitly

interface User {
  name?: string;
}

Override Keyword

Enforces correct method overriding

class Base {
  greet(): void {}
}
class Derived extends Base {
  override greet(): void {}
}

Template Literal Type Improvements

Supports better type inference

type Color = "red" | `light${string}`;

Template Literal Types

Allows type-safe string manipulation

type Greeting = `Hello, ${string}!`;

Variadic Tuple Types

Supports tuple manipulation

type MyTuple = [string, ...number[]];