TypeScript

https://www.typescriptlang.org/docs
Admin
TypeScript is a superset of JavaScript that adds static types, enabling developers to build more...
Tokens:332,107
Snippets:2,464
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Library file layout example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-plugin-d-ts.html

Example library file layout with multiple modules.

```text
myLib
  +---- index.js
  +---- foo.js
  +---- bar
         +---- index.js
         +---- baz.js
```

--------------------------------

### Example --explainFiles output

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html

Example output showing why lib.d.ts files and local files are included, with library references and include patterns.

```text
TS_Compiler_Directory/4.2.2/lib/lib.es5.d.ts
  Library referenced via 'es5' from file 'TS_Compiler_Directory/4.2.2/lib/lib.es2015.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.es2015.d.ts
  Library referenced via 'es2015' from file 'TS_Compiler_Directory/4.2.2/lib/lib.es2016.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.es2016.d.ts
  Library referenced via 'es2016' from file 'TS_Compiler_Directory/4.2.2/lib/lib.es2017.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.es2017.d.ts
  Library referenced via 'es2017' from file 'TS_Compiler_Directory/4.2.2/lib/lib.es2018.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.es2018.d.ts
  Library referenced via 'es2018' from file 'TS_Compiler_Directory/4.2.2/lib/lib.es2019.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.es2019.d.ts
  Library referenced via 'es2019' from file 'TS_Compiler_Directory/4.2.2/lib/lib.es2020.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.es2020.d.ts
  Library referenced via 'es2020' from file 'TS_Compiler_Directory/4.2.2/lib/lib.esnext.d.ts'
TS_Compiler_Directory/4.2.2/lib/lib.esnext.d.ts
  Library 'lib.esnext.d.ts' specified in compilerOptions
... More Library References...
foo.ts
  Matched by include pattern '**/*' in 'tsconfig.json'
```

--------------------------------

### Project structure for rootDirs example

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html

Shows the directory layout used in the rootDirs example: src/views and generated/templates/views contain files that import each other via relative paths.

```text
src
 └── views
     └── view1.ts (imports './template1')
     └── view2.ts

generated
 └── templates
         └── views
             └── template1.ts (imports './view2')
```

--------------------------------

### Rewritten example with multiple extends

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html

Rewrites the original example to use multiple extends, combining the strictest package with a local base configuration.

```jsonc
// packages/front-end/src/tsconfig.json
{
    "extends": ["@tsconfig/strictest/tsconfig.json", "../../../tsconfig.base.json"],
    "compilerOptions": {
        "outDir": "../lib",
        // ...
    }
}
```

--------------------------------

### Install tslib and compile with importHelpers

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html

Install the tslib utility library and compile with the importHelpers flag to emit imports to tslib instead of inlining helper functions.

```sh
npm install tslib
```

```sh
tsc --module commonjs --importHelpers a.ts
```

--------------------------------

### typesVersions file redirect example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html

Example package.json with typesVersions using a file redirect. For TypeScript 4.0 and above, imports resolve to ./index.d.ts; for 3.9 and below, to ./index.v3.d.ts.

```json
{
  "name": "package-name",
  "version": "1.0.0",
  "types": "./index.d.ts",
  "typesVersions": {
    "<4.0": { "index.d.ts": ["index.v3.d.ts"] }
  }
}

```

--------------------------------

### Declaration file layout example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-plugin-d-ts.html

Recommended declaration file layout mirroring the library layout.

```text
@types/myLib
  +---- index.d.ts
  +---- foo.d.ts
  +---- bar
         +---- index.d.ts
         +---- baz.d.ts
```

--------------------------------

### Global plugin usage example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-plugin-d-ts.html

Example from documentation of a global plugin that adds methods to built-in types. Shows usage of new methods on strings and arrays.

```js
var x = "hello, world";
// Creates new methods on built-in types
console.log(x.startsWithHello());
var y = [1, 2, 3];
// Creates new methods on built-in types
console.log(y.reverseAndSort());
```

--------------------------------

### Using global function greet

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the global function greet, which shows a greeting to the user.

```ts
greet("hello, world");
```

--------------------------------

### dramaticWelcome.ts async function example

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html

Example of an async function that uses await with a Promise, demonstrating downlevel async support.

```ts
function delay(milliseconds: number) {
  return new Promise<void>(resolve => {
    setTimeout(resolve, milliseconds);
  });
}
async function dramaticWelcome() {
  console.log("Hello");
  for (let i = 0; i < 3; i++) {
    await delay(500);
    console.log(".");
  }
  console.log("World!");
}
dramaticWelcome();
```

--------------------------------

### Original imports before any command

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html

Baseline example file used to illustrate the effect of each import-management command.

```ts
import { Zebra, Moose, HoneyBadger } from "./zoo";
import { foo, bar } from "./helper";
let x: Moose | HoneyBadger = foo();

```

--------------------------------

### RequireJS define example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html

Typical line in modular library documentation showing how to use define with a dependency.

```js
define(..., ['someLib'], function(someLib) {
});
```

--------------------------------

### UMD module output example (main.js)

Source: https://www.typescriptlang.org/docs/handbook/modules/reference.html

Emitted JavaScript for the `umd` module format example. It uses a UMD wrapper that supports CommonJS and AMD, but does not expose a global variable.

```js
// @Filename: main.js
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "mod", "mod"], factory);
    }
})(function (require, exports) {
    "use strict";
    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.e1 = void 0;
    const mod_1 = require("mod");
    const mod = require("mod");
    const dynamic = __syncRequire ? Promise.resolve().then(() => require("mod")) : new Promise((resolve_1, reject_1) => { require(["mod"], resolve_1, reject_1); });
    console.log(mod_1.default, mod_1.y, mod_1.z, mod, dynamic);
    exports.e1 = 0;
    exports.default = "default export";
});
```

--------------------------------

### Modular library require example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html

Typical line in modular library documentation showing how to require the library.

```js
var someLib = require("someLib");
```

--------------------------------

### UMD module input example (main.ts)

Source: https://www.typescriptlang.org/docs/handbook/modules/reference.html

Input TypeScript file for the `umd` module format example. It imports from "mod" and exports a named and default export.

```ts
// @Filename: main.ts
import x, { y, z } from "mod";
import * as mod from "mod";
const dynamic = import("mod");
console.log(x, y, z, mod, dynamic);
export const e1 = 0;
export default "default export";
```

--------------------------------

### Using myLib.makeGreeting and numberOfGreetings

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the global variable myLib, which has a function makeGreeting and a property numberOfGreetings.

```ts
let result = myLib.makeGreeting("hello, world");
console.log("The computed greeting is:" + result);
let count = myLib.numberOfGreetings;
```

--------------------------------

### typesVersions folder redirect example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html

Example package.json with typesVersions using a folder redirect. For TypeScript 3.1 and later, imports resolve to the ts3.1 folder; older versions fall back to the types field.

```json
{
  "name": "package-name",
  "version": "1.0.0",
  "types": "./index.d.ts",
  "typesVersions": {
    ">=3.1": { "*": ["ts3.1/*"] }
  }
}

```

--------------------------------

### Constructable module example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-plugin-d-ts.html

Shows a module that can be constructed with new, using the module-class.d.ts template.

```js
var x = require("bar");
// Note: using 'new' operator on the imported variable
var y = new x("hello");
```

--------------------------------

### Example files for esModuleInterop hazards

Source: https://www.typescriptlang.org/docs/handbook/modules/appendices/esm-cjs-interop.html

Example files showing a transpiled CommonJS dependency, a true CommonJS dependency, a TypeScript module, and a main file that imports them. Used to illustrate the hazards of `esModuleInterop` and the `__esModule` check.

```typescript
// @Filename: node_modules/transpiled-dependency/index.js
exports.__esModule = true;
exports.default = function doSomething() { /* ... */ };
exports.something = "something";
// @Filename: node_modules/true-cjs-dependency/index.js
module.exports = function doSomethingElse() { /* ... */ };
// @Filename: src/sayHello.ts
export default function sayHello() { /* ... */ }
export const hello = "hello";
// @Filename: src/main.ts
import doSomething from "transpiled-dependency";
import doSomethingElse from "true-cjs-dependency";
import sayHello from "./sayHello.js";
```

--------------------------------

### Global library assigning to window

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-d-ts.html

Example of a global library that assigns a function to a global `window` property.

```js
window.createGreeting = function (s) {
  return "Hello, " + s;
};
```

--------------------------------

### Global library with top-level function

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-d-ts.html

Example of a simple global library that defines a top-level function.

```js
function createGreeting(s) {
  return "Hello, " + s;
}
```

--------------------------------

### Example: Parameters starting with underscore are exempt

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html

Demonstrates that parameters whose names start with an underscore are exempt from unused parameter checking.

```typescript
function returnNull(_a) {
  // OK
  return null;
}
```

--------------------------------

### Install TypeScript nightly build

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-6.html

Install the nightly build of TypeScript globally using npm. This command is used to get the latest nightly release.

```bash
npm install -g typescript@next
```

--------------------------------

### get and set accessors in ambient contexts

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-6.html

Allows get and set accessors in ambient contexts (declare classes or .d.ts files) starting in TypeScript 3.6. In 3.7, the compiler will emit get/set accessors in generated .d.ts files.

```ts
declare class Foo {
  // Allowed in 3.6+.
  get x(): number;
  set x(val: number);
}

```

--------------------------------

### Using Greeter with log and alert options

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the greeter object, which can log to a file or display an alert with LogOptions and alert options.

```ts
const g = new Greeter("Hello");
g.log({ verbose: true });
g.alert({ modal: false, title: "Current Greeting" });
```

--------------------------------

### Code with highlighted range for extraction

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-9.html

Example code used to demonstrate the newline-preserving behavior of TypeScript refactorings. The range from /*start*/ to /*end*/ is highlighted to extract to a new function.

```ts
const maxValue = 100;
/*start*/
for (let i = 0; i <= maxValue; i++) {
  // First get the squared value.
  let square = i ** 2;
  // Now print the squared value.
  console.log(square);
}
/*end*/
```

--------------------------------

### Import and use lodash in TypeScript

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html

Use lodash in TypeScript code after installing its type declarations. This example works for both modules and global code, and demonstrates importing the library and calling the padStart method.

```ts
import * as _ from "lodash";
_.padStart("Hello TypeScript!", 20, " ");
```

--------------------------------

### Using Greeter class and extending it

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the Greeter class, including instantiation, property assignment, method call, and extending the class.

```ts
const myGreeter = new Greeter("hello, world");
myGreeter.greeting = "howdy";
myGreeter.showGreeting();
class SpecialGreeter extends Greeter {
  constructor() {
    super("Very special greetings");
  }
}
```

--------------------------------

### package.json with dependencies for browserify and typescript

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html

Example package.json for a package that depends on browserify and typescript. It includes @types/browserify because browserify does not bundle its declarations, while typescript does. Dependencies are listed in dependencies, not devDependencies, so consumers get them automatically.

```json
{
  "name": "browserify-typescript-extension",
  "author": "Vandelay Industries",
  "version": "1.0.0",
  "main": "./lib/main.js",
  "types": "./lib/main.d.ts",
  "dependencies": {
    "browserify": "latest",
    "@types/browserify": "latest",
    "typescript": "next"
  }
}
```

--------------------------------

### Using greet with GreetingSettings

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the greet function, which expects a GreetingSettings object with a mandatory greeting string and optional duration and color properties.

```ts
greet({
  greeting: "hello world",
  duration: 4000
});
```

--------------------------------

### Forward --explainFiles output to a file or pipe to a utility

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html

Forward the output to a text file, or pipe it to a utility like less or an editor like VS Code for easier reading.

```sh
# Forward output to a text file
tsc --explainFiles > explanation.txt
# Pipe output to a utility program like `less`, or an editor like VS Code
tsc --explainFiles | less
tsc --explainFiles | code -
```

--------------------------------

### Conditional type example: TypeName

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html

Example of a conditional type that maps a type to a string literal. The comments show the resolved types for several instantiations.

```ts
type TypeName<T> = T extends string
  ? "string"
  : T extends number
  ? "number"
  : T extends boolean
  ? "boolean"
  : T extends undefined
  ? "undefined"
  : T extends Function
  ? "function"
  : "object";
type T0 = TypeName<string>; // "string"
type T1 = TypeName<"a">; // "string"
type T2 = TypeName<true>; // "boolean"
type T3 = TypeName<() => void>; // "function"
type T4 = TypeName<string[]>; // "object"
```

--------------------------------

### tsconfig.json example

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-5.html

Example tsconfig.json file that specifies compiler options for a TypeScript project. The compiler searches for this file when tsc is invoked with no input files.

```json
{
  "compilerOptions": {
    "module": "commonjs",
    "noImplicitAny": true,
    "sourceMap": true
  }
}
```

--------------------------------

### Use optional parameters vs overloads: correct example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html

Shows the recommended way using optional parameters instead of multiple overloads. This collapsing only works when all overloads have the same return type.

```ts
ts
/* OK */
interface Example {
  diff(one: string, two?: string, three?: boolean): number;
}

```

--------------------------------

### Using greet with GreetingLike types

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the greet function, which accepts a string, a function returning a string, or a Greeter instance.

```ts
function getGreeting() {
  return "howdy";
}
class MyGreeter extends Greeter {}
greet("hello");
greet(getGreeting);
greet(new MyGreeter());
```

--------------------------------

### Directory module index file resolution example

Source: https://www.typescriptlang.org/docs/handbook/modules/reference.html

Shows TypeScript resolving `./dir` to `dir/index.ts` via index file lookup. The `@Filename` comments indicate the file names used in the example.

```typescript
// @Filename: dir/index.ts
export {};
// @Filename: b.ts
import {} from "./dir";

```

--------------------------------

### Build with and without --declaration under --build

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html

These commands show how to build a project with declaration emit off by default and then enable it for a production build by passing the --declaration flag under --build mode.

```sh
tsc --build -p ./my-project-dir
```

```sh
tsc --build -p ./my-project-dir --declaration
```

--------------------------------

### Using a global library (jQuery example)

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-d-ts.html

Shows how a global library like jQuery is used without imports, by referencing the global `$` variable.

```ts
$(() => {
  console.log("hello!");
});
```

--------------------------------

### Example module requiring cross-file type-checking

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html

Example module that requires cross-file type-checking to generate a declaration file because the exported function foo returns a value whose type depends on the implementation of add.

```ts
import { add } from "./add";
const x = add();
export function foo() {
    return x;
}
```

--------------------------------

### Example: noUnusedParameters and noUnusedLocals

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html

Shows how the compiler flags unused imports, parameters, and locals when noUnusedParameters and noUnusedLocals are enabled. The example includes an unused import B and an unused parameter args, both marked with errors.

```typescript
import B, { readFile } from "./b";
//     ^ Error: `B` declared but never used
readFile();
export function write(message: string, args: string[]) {
  //                                 ^^^^  Error: 'arg' declared but never used.
  console.log(message);
}
```

--------------------------------

### SystemJS output example (system)

Source: https://www.typescriptlang.org/docs/handbook/modules/reference.html

Shows TypeScript source and its System.register output for the system module format, designed for the SystemJS module loader.

```typescript
// @Filename: main.ts
import x, { y, z } from "mod";
import * as mod from "mod";
const dynamic = import("mod");
console.log(x, y, z, mod, dynamic);
export const e1 = 0;
export default "default export";
```

```javascript
// @Filename: main.js
System.register(["mod"], function (exports_1, context_1) {
    "use strict";
    var mod_1, mod, dynamic, e1;
    var __moduleName = context_1 && context_1.id;
    return {
        setters: [
            function (mod_1_1) {
                mod_1 = mod_1_1;
                mod = mod_1_1;
            }
        ],
        execute: function () {
            dynamic = context_1.import("mod");
            console.log(mod_1.default, mod_1.y, mod_1.z, mod, dynamic);
            exports_1("e1", e1 = 0);
            exports_1("default", "default export");
        }
    };
});
```

--------------------------------

### Using global variable foo

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html

Usage example for the global variable foo, which contains the number of widgets present.

```ts
console.log("Half the number of widgets is " + foo / 2);
```

--------------------------------

### tsconfig.json exclude property example

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-6.html

Use this tsconfig.json example to exclude files and directories from compilation when no files property is specified. The exclude property must be an array of strings relative to the tsconfig.json location and does not support wildcards.

```json
{
  "compilerOptions": {
    "out": "test.js"
  },
  "exclude": ["node_modules", "test.ts", "utils/t2.ts"]
}
```

--------------------------------

### Use optional parameters vs overloads: wrong example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html

Shows multiple overloads differing only in trailing parameters, which is discouraged; prefer optional parameters.

```ts
ts
/* WRONG */
interface Example {
  diff(one: string): number;
  diff(one: string, two: string): number;
  diff(one: string, two: string, three: boolean): number;
}

```

--------------------------------

### Module class template usage

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html

Shows how to use a module that can be constructed with new.

```js
const x = require("bar");
// Note: using 'new' operator on the imported variable
const y = new x("hello");
```

--------------------------------

### Controlling literal type widening with annotations

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html

Shows how explicit literal type annotations control literal type widening: without annotation, const gets a widening type; with annotation, it gets a non-widening type.

```ts
const c1 = "hello"; // Widening type "hello"
let v1 = c1; // Type string
const c2: "hello" = "hello"; // Type "hello"
let v2 = c2; // Type "hello"
```

--------------------------------

### Run tsc --explainFiles

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html

Use the --explainFiles flag to get verbose output about why files are included in your program.

```sh
tsc --explainFiles
```

--------------------------------

### Install @types/lodash with npm

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html

Install type declarations for lodash from the @types scope. Use the --save-dev flag to add the package as a development dependency. This command requires npm and is the standard way to obtain type declarations for libraries that do not include their own.

```cmd
npm install --save-dev @types/lodash
```

--------------------------------

### Examples of always-truthy or nullish checks

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html

These examples show common mistakes that TypeScript 5.6 now flags as errors: a regex literal used as a condition, an arrow function `=>` mistaken for `>=`, a nullish coalescing expression with incorrect precedence, and a misplaced parenthesis in a complex boolean expression.

```ts
if (/0x[0-9a-f]/) {
    // Oops! This block always runs.
    // ...
}
```

```ts
if (x => 0) {
    // Oops! This block always runs.
    // ...
}
```

```ts
function isValid(value: string | number, options: any, strictness: "strict" | "loose") {
    if (strictness === "loose") {
        value = +value
    }
    return value < options.max ?? 100;
    // Oops! This is parsed as (value < options.max) ?? 100
}
```

```ts
if (
    isValid(primaryValue, "strict") || isValid(secondaryValue, "strict") ||
    isValid(primaryValue, "loose" || isValid(secondaryValue, "loose"))
) {
    //                           ^^^^ 👀 Did we forget a closing ')'?
}
```

--------------------------------

### Default import

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-5.html

Shows how to import a default export using `import Greeter from "./greeter";` and then use it.

```ts
import Greeter from "./greeter";
var g = new Greeter();
g.sayHello();
```

--------------------------------

### Module augmentation example (observable.ts)

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-8.html

Defines an Observable class that will be augmented by map.ts.

```ts
// observable.ts
export class Observable<T> {
  // ...
}
```

--------------------------------

### var hoisting example

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-4.html

Shows how var declarations are hoisted, causing a confusing bug where console.log(x) runs before x is assigned.

```ts
console.log(x); // meant to write 'y' here
/* later in the same block */
var x = "hello";
```

--------------------------------

### Using map and take on a generator

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html

Shows that generators now produce objects with map and take methods. The example creates an infinite generator of positive integers, maps it to even numbers, and takes the first five values.

```ts
function* positiveIntegers() {
    let i = 1;
    while (true) {
        yield i;
        i++;
    }
}
const evenNumbers = positiveIntegers().map(x => x * 2);
// Output:
//    2
//    4
//    6
//    8
//   10
for (const value of evenNumbers.take(5)) {
    console.log(value);
}
```

--------------------------------

### Weak type definition example

Source: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html

Defines a weak type with all-optional properties.

```ts
interface Options {
  data?: string;
  timeout?: number;
  maxRetries?: number;
}
```

--------------------------------

### CommonJS require example

Source: https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html

Shows how to import a module in JavaScript CommonJS (Node.js).

```js
var fs = require("fs");
```
Tokens:
Raw