TypeScript 66 🔷 Typing Node.js APIs - KandZ

Node.js is written in JavaScript, and JavaScript does not ship type information. When you write import { readFile } from "fs" in a TypeScript project, the compiler has no idea what readFile accepts, what it returns, or whether the callback’s error parameter is Error or null. The types for Node.js’s built-in modules live in a separate package — @types/node — and the package is the foundation of every TypeScript backend. This chapter covers what @types/node is, how the compiler finds it, how to type the environment variables, the file system, the streams, the HTTP server, and the Express types that build on it. It is the practical companion to TypeScript 62’s @types material, and it applies the general mechanism to the specific and important case of Node.js.

Key point: @types/node is the community-maintained package that contains the TypeScript declarations for Node.js’s built-in modules. It is a development-only dependency — it contains no runtime code — and it should be installed in devDependencies. The package’s major version tracks the Node.js runtime’s major version, so a Node 20 project uses @types/node@^20. The declarations cover fs, http, path, process, stream, and the rest. The process.env is typed as Record<string, string | undefined>, and the augmentation of the NodeJS.ProcessEnv interface is the way to type the environment variables. The http module’s IncomingMessage and ServerResponse are the base types, and Express’s Request and Response are the wrappers that the @types/express package provides.

What `@types/node` is

@types/node is the TypeScript declaration package for Node.js. It contains only .d.ts files, and it is published from the DefinitelyTyped repository .

The package’s content. The package has the declarations for the built-in modules: the fs, the http, the https, the path, the os, the crypto, the stream, the events, the process, the buffer, and the rest. The declarations describe the shapes, and the compiler uses them for the checking .

Why it is a development dependency. The package contains no runtime code. It exists only for the compiler, and the production runtime does not need it. The npm install --save-dev @types/node is the correct installation, and the dependencies is the mistake .

Why the version matters. The package’s major version tracks the Node.js runtime’s major version. A project on Node 20 uses @types/node@^20, and a project on Node 22 uses @types/node@^22. The mismatch produces the type errors for the methods that exist at runtime but not in the older declarations, or the missing errors for the signatures that changed .

Why the automatic discovery. The compiler looks in node_modules/@types by default, and the @types/node package is found without an import. The tsconfig.json‘s types array can limit the loaded packages, but the node is the common and the automatic .

Why the package is not the Node.js’s. The package is maintained by the DefinitelyTyped community, not by the Node.js core team. The community writes the declarations, and the review process is the quality control. The package is one of the most downloaded on npm, and the dependency is nearly universal in TypeScript backends .

Why the package can be the supply chain concern. The package is a dependency, and it is widely trusted. The DefinitelyTyped review is the mitigating control, and the provenance hygiene applies. The package’s compromise could poison the developer machines through the build tooling, even though it has no runtime code .

Why the Node.js’s built-in type stripping matters. The modern Node.js can run the TypeScript files with the type stripping, which removes the inline types without the type checking. The --experimental-strip-types is the flag, and the feature is the lightweight. The full support requires the third-party tools like the tsx .

Why the @types/node is the first install. A TypeScript Node.js project installs the @types/node before the other types. The package is the foundation, and the other packages — the @types/express, the @types/node-fetch — depend on it or build on it. The installation is the first step, and the step is the universal.

The `process.env` typing

The process.env is typed as Record<string, string | undefined>, which means every access is a string | undefined and requires a check. The augmentation of the NodeJS.ProcessEnv interface is the way to type the specific variables.

// src/process.d.ts
declare global {
  namespace NodeJS {
    interface ProcessEnv {
      NODE_ENV?: 'development' | 'production' | 'test';
      DATABASE_URL?: string;
      PORT?: string;
      JWT_SECRET?: string;
    }
  }
}

export {};

The augmentation adds the variables to the ProcessEnv interface, and the process.env.DATABASE_URL is typed as string | undefined. The export {} makes the file a module, which is required for the declare global block .

Why the variables are optional. The ? makes the variables optional, which reflects the runtime’s possibility. The environment may or may not set the variable, and the type says string | undefined. The check is the requirement, and the check is the safety .

Why the NODE_ENV can be the union. The NODE_ENV is the common, and the union of the literals is the precise type. The 'development' | 'production' | 'test' is the union, and the typo is the compile error .

Why the validation is the runtime check. The augmentation is the compile-time claim, and the runtime does not verify it. The validation is the runtime check, and the if (!process.env.DATABASE_URL) throw new Error(...) is the pattern. The two are the pair, and the pair is the safety .

Why the alternative is the intersection. The type UnvalidatedInputs = NodeJS.ProcessEnv & { A?: string } is the alternative, and the intersection is the typing. The ProcessEnv is the base, and the specific is the addition. The pattern is the alternative, and the augmentation is the common .

Why the process is the global. The process is a Node.js global, and it is not imported. The import * as process from "node:process" is the unnecessary, and the process.env is the global. The TypeScript knows the global when the @types/node is installed .

Why the environment variables are the configuration. The environment is the deployment’s, and the variables are the configuration. The type is the documentation, and the validation is the check. The two are the pattern, and the pattern is the modern.

The `fs` module typing

The fs module has the callback and the Promise APIs, and each has the types. The fs.readFile has the overloads, and the callback’s error is NodeJS.ErrnoException | null.

import { readFile } from 'node:fs';

readFile('/path/to/file', 'utf8', (err, data) => {
  if (err) {
    // err is NodeJS.ErrnoException | null
    console.error(err.message);
    return;
  }
  // data is string
  console.log(data);
});

The err is the NodeJS.ErrnoException | null, and the data is the string (because of the 'utf8' encoding). The callback’s types are the inferred, and the check is the requirement.

The Promise API. The fs/promises module has the Promise-based API, and the types are the Promise<T>.

import { readFile } from 'node:fs/promises';

const data = await readFile('/path/to/file', 'utf8');
// data is string

The readFile returns the Promise<string>, and the await unwraps the string. The Promise API is the modern, and the use is the async/await .

Why the overloads matter. The fs module has many overloads, and the return type depends on the arguments. The readFile with the 'utf8' returns the string, and the readFile without the encoding returns the Buffer. The overloads are the types, and the inference is the choice.

Why the fs.ReadStream is the type. The createReadStream returns the fs.ReadStream, which extends the stream.Readable. The type is the specific, and the stream methods are the available .

Why the process.stdin is the type. The process.stdin is the NodeJS.ReadStream, and the intersection with the fd: 0 is the specific. The type is the stream, and the use is the input .

Why the fs.PathLike is the type. The PathLike is the string | Buffer | URL, and the argument accepts the three. The type is the union, and the acceptance is the flexibility.

Why the fs module is the common. The fs is the file system’s, and the use is the file’s. The types are the safety, and the callback’s error is the check. The module is the foundation, and the foundation is the common.

The `stream` module typing

The stream module has the Readable, the Writable, the Duplex, and the Transform. The types are the base classes, and the custom streams extend them.

import { Transform, TransformCallback } from 'node:stream';

class UppercaseTransform extends Transform {
  _transform(chunk: Buffer, encoding: string, callback: TransformCallback): void {
    const upperChunk = chunk.toString().toUpperCase();
    this.push(upperChunk);
    callback();
  }
}

The Transform is the base class, and the _transform method is the override. The chunk is the Buffer, the encoding is the string, and the callback is the TransformCallback. The types are the precise, and the override is the correct .

Why the TransformCallback matters. The TransformCallback is the callback’s type, and the signature is the (error?: Error | null, data?: any) => void. The type ensures the callback’s correct use, and the implementation is the safe .

The pipe method. The pipe method connects the readable to the writable, and the return type is the Writable.

readStream.pipe(transformStream).pipe(writeStream);

The pipe returns the destination, and the chain is the pattern. The types are the flow, and the chain is the composition .

The pipeline function. The pipeline function connects the multiple streams, and the callback’s error is the Error | null.

import { pipeline } from 'node:stream';

pipeline(source, gzip, destination, (err: Error | null) => {
  if (err) {
    console.error('Compression failed:', err);
    return;
  }
  console.log('File compressed successfully!');
});

The pipeline is the modern, and the callback is the error’s. The pipeline is the recommended, and the pipe is the older .

Why the stream types matter. The streams are the data’s flow, and the types are the safety. The custom stream’s _transform is the override, and the TransformCallback is the callback. The types are the precise, and the precise is the safe.

Why the encoding is the string. The encoding is the string, and the 'utf8' is the common. The chunk is the Buffer, and the toString is the conversion. The two are the pair, and the pair is the pattern.

Why the stream module is the advanced. The streams are the advanced, and the use is the file’s, the network’s, the compression’s. The types are the safety, and the safety is the value.

The `http` module typing

The http module has the IncomingMessage and the ServerResponse, which are the request and the response. The Express’s Request and Response are the wrappers that the @types/express provides.

import { createServer, IncomingMessage, ServerResponse } from 'node:http';

const server = createServer((req: IncomingMessage, res: ServerResponse) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, world!\n');
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

The IncomingMessage is the request, and the ServerResponse is the response. The req is the IncomingMessage, and the res is the ServerResponse. The types are the base, and the Express’s are the wrappers .

Why the IncomingMessage is the request. The IncomingMessage has the url, the method, the headers, and the on for the data’s events. The type is the base, and the use is the low-level.

Why the ServerResponse is the response. The ServerResponse has the writeHead, the write, the end, and the statusCode. The type is the base, and the use is the low-level.

The Express’s Request. The @types/express‘s Request extends the http.IncomingMessage, and it adds the params, the query, the body, and the locals.

import { Request, Response } from 'express';

app.get('/users/:userId', (req: Request, res: Response) => {
  const userId = req.params.userId;
  res.json({ userId });
});

The Request is the Express’s, and the req.params is the ParamsDictionary. The type is the Express’s, and the use is the common .

Why the Express’s generics matter. The Request is generic over the P, the ResBody, the ReqBody, and the ReqQuery.

interface UserParams {
  userId: string;
}

interface UserBody {
  name: string;
  email: string;
}

app.patch('/users/:userId', (
  req: Request<UserParams, {}, UserBody>,
  res: Response
) => {
  const userId = req.params.userId;  // string
  const { name, email } = req.body;  // string, string
});

The Request<UserParams, {}, UserBody> is the typed, and the req.params.userId is the string. The generics are the precise, and the precise is the safety .

Why the generics default to any. The Request‘s defaults are the ParamsDictionary, the any, the any, and the ParsedQs. The defaults are the danger, and the precise is the mission. The any is the wild, and the precise is the replacement .

Why the Response is generic. The Response<ResBody> is the response’s body’s type, and the res.json(data) is the checked. The generic is the response’s, and the use is the precise .

Why the NextFunction is the third. The NextFunction is the middleware’s, and the next() is the call. The type is the (err?: any) => void, and the use is the middleware’s .

Why the Express’s types are the wrapper. The Express’s types build on the Node.js’s, and the @types/express depends on the @types/node. The two are the pair, and the pair is the common. The @types/express is the installation, and the @types/node is the foundation .

The `path` module typing

The path module has the join, the resolve, the basename, the dirname, and the extname. The types are the string’s, and the return is the string.

import { join, resolve, basename } from 'node:path';

const fullPath = join('/users', 'alice', 'file.txt');
// fullPath is string

const absolutePath = resolve('/users', 'alice');
// absolutePath is string

const fileName = basename('/users/alice/file.txt');
// fileName is string

The join returns the string, and the basename returns the string. The types are the simple, and the use is the common.

Why the path types are the simple. The path module’s arguments and returns are the strings, and the types are the simple. The join is the string’s, and the basename is the string’s. The types are the straightforward, and the use is the frequent.

Why the path module is the foundation. The path is the file system’s, and the use is the file’s. The types are the simple, and the simple is the common.

Why the path module is the cross-platform. The path handles the separator, and the Windows’s \ and the Linux’s / are the difference. The path.join is the cross-platform, and the path.posix and the path.win32 are the specific.

Why the path module is the common. The path is the file’s, and the use is the frequent. The types are the simple, and the simple is the daily.

Complete Example Session

// ============================================
// PART 1: THE PROCESS.ENV
// ============================================

// src/process.d.ts
declare global {
  namespace NodeJS {
    interface ProcessEnv {
      NODE_ENV?: 'development' | 'production' | 'test';
      DATABASE_URL?: string;
      PORT?: string;
      JWT_SECRET?: string;
    }
  }
}

export {};

// The usage:
const env = process.env.NODE_ENV;  // 'development' | 'production' | 'test' | undefined

// ============================================
// PART 2: THE FS MODULE
// ============================================

import { readFile, createReadStream } from 'node:fs';
import { readFile as readFilePromise } from 'node:fs/promises';

// The callback:
readFile('/path/to/file', 'utf8', (err, data) => {
  if (err) {
    console.error(err.message);
    return;
  }
  console.log(data);  // string
});

// The Promise:
const data = await readFilePromise('/path/to/file', 'utf8');
// data is string

// The stream:
const stream = createReadStream('/path/to/file');
// stream is fs.ReadStream

// ============================================
// PART 3: THE STREAM MODULE
// ============================================

import { Transform, TransformCallback, pipeline } from 'node:stream';
import { createReadStream, createWriteStream } from 'node:fs';
import { createGzip } from 'node:zlib';

class UppercaseTransform extends Transform {
  _transform(chunk: Buffer, encoding: string, callback: TransformCallback): void {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
}

const source = createReadStream('data.txt');
const destination = createWriteStream('data.txt.gz');
const gzip = createGzip();

pipeline(source, gzip, destination, (err: Error | null) => {
  if (err) {
    console.error('Compression failed:', err);
    return;
  }
  console.log('File compressed successfully!');
});

// ============================================
// PART 4: THE HTTP MODULE
// ============================================

import { createServer, IncomingMessage, ServerResponse } from 'node:http';

const server = createServer((req: IncomingMessage, res: ServerResponse) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, world!\n');
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

// ============================================
// PART 5: THE EXPRESS TYPES
// ============================================

import express, { Request, Response, NextFunction } from 'express';

const app = express();
app.use(express.json());

interface UserParams {
  userId: string;
}

interface UserBody {
  name: string;
  email: string;
}

app.patch('/users/:userId', (
  req: Request<UserParams, {}, UserBody>,
  res: Response,
  next: NextFunction
) => {
  const userId = req.params.userId;  // string
  const { name, email } = req.body;  // string, string
  res.json({ userId, name, email });
});

// ============================================
// PART 6: THE PATH MODULE
// ============================================

import { join, resolve, basename, extname } from 'node:path';

const fullPath = join('/users', 'alice', 'file.txt');  // string
const absolutePath = resolve('/users', 'alice');       // string
const fileName = basename('/users/alice/file.txt');    // string
const extension = extname('/users/alice/file.txt');    // string

// ============================================
// PART 7: THE REQUEST AUGMENTATION
// ============================================

// src/express.d.ts
import 'express';

declare module 'express' {
  interface Request {
    user?: {
      id: string;
      roles: string[];
    };
    requestId: string;
  }
}

// The usage:
app.get('/profile', (req: Request, res: Response) => {
  if (req.user) {
    console.log(req.user.id);
  }
});

// ============================================
// PART 8: THE CUSTOM MIDDLEWARE
// ============================================

function authMiddleware(req: Request, res: Response, next: NextFunction): void {
  const token = req.headers.authorization;
  if (!token) {
    res.status(401).json({ error: 'Unauthorized' });
    return;
  }
  // The validation:
  req.user = { id: '1', roles: ['admin'] };
  next();
}

app.use(authMiddleware);

// ============================================
// PART 9: THE VALIDATION MIDDLEWARE
// ============================================

import { AnyZodObject, ZodError } from 'zod';

const validate = (schema: AnyZodObject) => {
  return async (req: Request, res: Response, next: NextFunction) => {
    try {
      const validated = await schema.parseAsync({
        body: req.body,
        query: req.query,
        params: req.params,
      });
      req.body = validated.body;
      req.query = validated.query;
      req.params = validated.params;
      next();
    } catch (error) {
      if (error instanceof ZodError) {
        res.status(400).json({ errors: error.errors });
        return;
      }
      next(error);
    }
  };
};

// ============================================
// PART 10: WHAT NOT TO DO
// ============================================

// Don't put @types/node in dependencies
// It contains no runtime code.

// Don't mismatch the @types/node version
// Use @types/node@^20 for Node 20.

// Don't rely on the augmentation without validation
// The type is a claim, not a guarantee.

// Don't use the any defaults in the Express generics
// Request<Params, {}, Body> is the precise.

// Don't forget the export {} in the declaration file
// The declare global block requires the module.

// Don't cast the process.env
// Use the augmentation and the validation.

The ten parts cover the process.env, the fs module, the stream module, the http module, the Express types, the path module, the request augmentation, the custom middleware, the validation middleware, and the anti-patterns.

Quick Reference

The `@types/node`

Aspect	Value
The content	The declarations for the built-in modules
The dependency	The `devDependencies`
The version	The Node.js runtime’s major
The discovery	The automatic
The source	The DefinitelyTyped

The `process.env`

Pattern	Code
The augmentation	`declare global { namespace NodeJS { interface ProcessEnv { ... } } }`
The optional	The `?`
The validation	The runtime check
The alternative	The intersection

The `fs` Module

Method	The return
`readFile` (the callback)	The `void`
`readFile` (the Promise)	The `Promise<Buffer \| string>`
`createReadStream`	The `fs.ReadStream`
`createWriteStream`	The `fs.WriteStream`

The `stream` Module

Class	The use
`Readable`	The source
`Writable`	The destination
`Duplex`	The both
`Transform`	The conversion

The `http` Module

Type	The use
`IncomingMessage`	The request
`ServerResponse`	The response
`createServer`	The server

The Express Types

Type	The use
`Request<P, ResBody, ReqBody, ReqQuery>`	The request
`Response<ResBody>`	The response
`NextFunction`	The middleware

The `path` Module

Method	The return
`join`	The `string`
`resolve`	The `string`
`basename`	The `string`
`extname`	The `string`

Best Practices

✅ Do This:

// Install @types/node in devDependencies
npm install --save-dev @types/node                                 // ✅

// Match the version
// Node 20 → @types/node@^20                                        // ✅

// Augment the ProcessEnv
declare global {
  namespace NodeJS {
    interface ProcessEnv { DATABASE_URL?: string; }
  }
}
export {};                                                         // ✅

// Validate the environment
if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is required'); // ✅

// Use the Express generics
Request<UserParams, {}, UserBody>                                  // ✅

// Augment the Express Request
declare module 'express' { interface Request { user?: User; } }   // ✅

// Use the Promise fs API
const data = await readFile('/path', 'utf8');                      // ✅

// Use the pipeline
pipeline(source, gzip, destination, (err) => { ... });             // ✅

❌ Don’t Do This:

// Don't put @types/node in dependencies
{ "dependencies": { "@types/node": "^20.0.0" } }                   // ⚠️

// Don't mismatch the version
// Node 20 with @types/node@^18                                     // ⚠️

// Don't rely on the augmentation without validation
process.env.DATABASE_URL  // string | undefined                    // ⚠️

// Don't use the any defaults in Express
Request  // params, body, query are any                             // ⚠️

// Don't forget the export {} in the declaration
declare global { ... }  // ❌ the module is required               // ⚠️

// Don't cast the process.env
const env = process.env as Record<string, string>;                  // ⚠️

Common Pitfalls

Pitfall	Problem	Solution
The `@types/node` in dependencies	The production bloat	Move to dev
The version mismatch	The wrong types	Match the runtime
The missing validation	The runtime error	Check the variable
The `any` Express generics	The unchecked	Use the precise
The missing `export {}`	The augmentation fails	Add it
The `process.env` cast	The lost typing	Use the augmentation
The `pipeline` error	The unhandled	Check the callback
The `fs` overload	The wrong type	Use the encoding

Real-World Examples

1. The `process.env` augmentation

declare global {
  namespace NodeJS {
    interface ProcessEnv {
      DATABASE_URL?: string;
    }
  }
}
export {};

2. The environment validation

if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is required');

3. The `fs` Promise

const data = await readFile('/path', 'utf8');

4. The `fs` stream

const stream = createReadStream('/path');

5. The `Transform` stream

class UppercaseTransform extends Transform {
  _transform(chunk: Buffer, encoding: string, callback: TransformCallback): void {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
}

6. The `pipeline`

pipeline(source, gzip, destination, (err: Error | null) => { ... });

7. The `http` server

createServer((req: IncomingMessage, res: ServerResponse) => { ... });

8. The Express generics

Request<UserParams, {}, UserBody>

9. The Express Request augmentation

declare module 'express' {
  interface Request { user?: User; }
}

10. The `path` join

const fullPath = join('/users', 'alice', 'file.txt');

Visual: The `@types/node`

┌──────────────────────────────────────────────────────────┐
│  THE TYPESCRIPT PROJECT                                  │
│    │                                                     │
│    │  import { readFile } from 'fs'                      │
│    │                                                     │
│    ▼                                                     │
│  THE COMPILER                                            │
│    │                                                     │
│    ├── node_modules/@types/node/                         │
│    │     The fs.d.ts, the http.d.ts, the path.d.ts       │
│    │                                                     │
│    └── The types are the declarations.                   │
│                                                          │
│  The @types/node is the development's, and the runtime   │
│  does not need it.                                       │
│                                                          │
└──────────────────────────────────────────────────────────┘

Visual: The `process.env`

┌──────────────────────────────────────────────────────────┐
│  WITHOUT THE AUGMENTATION                                │
│                                                          │
│  process.env.DATABASE_URL                                │
│    → string | undefined                                  │
│    The check is required.                                │
│                                                          │
├──────────────────────────────────────────────────────────┤
│  WITH THE AUGMENTATION                                   │
│                                                          │
│  declare global {                                        │
│    namespace NodeJS {                                    │
│      interface ProcessEnv { DATABASE_URL?: string; }     │
│    }                                                     │
│  }                                                       │
│                                                          │
│  process.env.DATABASE_URL                                │
│    → string | undefined (the auto-complete)              │
│    The check is still required.                          │
│                                                          │
│  The augmentation is the documentation, and the          │
│  validation is the safety.                               │
│                                                          │
└──────────────────────────────────────────────────────────┘

Visual: The Express Request

┌──────────────────────────────────────────────────────────┐
│  THE GENERICS                                            │
│                                                          │
│  Request<P, ResBody, ReqBody, ReqQuery>                  │
│    │       │         │        │                          │
│    │       │         │        └── the query's type       │
│    │       │         └── the body's type                 │
│    │       └── the response's body's type                │
│    └── the params' type                                  │
│                                                          │
│  THE PRECISE                                             │
│                                                          │
│  interface UserParams { userId: string; }                │
│  interface UserBody { name: string; email: string; }     │
│                                                          │
│  Request<UserParams, {}, UserBody>                       │
│    req.params.userId  → string                           │
│    req.body.name      → string                           │
│                                                          │
│  THE DEFAULT                                             │
│                                                          │
│  Request                                                 │
│    req.params  → ParamsDictionary                        │
│    req.body    → any                                     │
│                                                          │
│  The precise is the safety.                              │
│                                                          │
└──────────────────────────────────────────────────────────┘

Visual: The Stream Pipeline

┌──────────────────────────────────────────────────────────┐
│  const source = createReadStream('data.txt');            │
│  const destination = createWriteStream('data.txt.gz');   │
│  const gzip = createGzip();                              │
│                                                          │
│  pipeline(source, gzip, destination, (err) => {          │
│    if (err) { ... }                                      │
│  });                                                     │
│                                                          │
│  THE FLOW                                                │
│                                                          │
│  source (Readable)                                       │
│    │                                                     │
│    ▼                                                     │
│  gzip (Transform)                                        │
│    │                                                     │
│    ▼                                                     │
│  destination (Writable)                                  │
│                                                          │
│  The pipeline is the modern, and the callback is the     │
│  error's.                                                │
│                                                          │
└──────────────────────────────────────────────────────────┘

Visual: The Declaration Files

┌──────────────────────────────────────────────────────────┐
│  src/process.d.ts                                        │
│    declare global {                                      │
│      namespace NodeJS {                                  │
│        interface ProcessEnv { ... }                      │
│      }                                                   │
│    }                                                     │
│    export {};                                            │
│                                                          │
│  src/express.d.ts                                        │
│    import 'express';                                     │
│    declare module 'express' {                            │
│      interface Request { user?: User; }                  │
│    }                                                     │
│                                                          │
│  The two files are the augmentation, and the files are   │
│  the types.                                              │
│                                                          │
└──────────────────────────────────────────────────────────┘

Summary

Item	Value
`@types/node`	The Node.js declarations
The dependency	The `devDependencies`
The version	The Node.js runtime’s major
The `process.env`	The `Record<string, string \| undefined>`
The augmentation	The `NodeJS.ProcessEnv`
The Express’s `Request`	The generic
The `fs`	The callback and the Promise
The `stream`	The `Readable`, the `Writable`, the `Transform`
The `http`	The `IncomingMessage`, the `ServerResponse`
The `path`	The `join`, the `resolve`

Key takeaways:

@types/node is the community-maintained package for the Node.js’s built-in modules — it contains only the .d.ts files, and it is a development-only dependency
The package’s major version tracks the Node.js runtime’s major — a Node 20 project uses @types/node@^20, and the mismatch produces the type errors
The process.env is typed as Record<string, string | undefined> — the augmentation of the NodeJS.ProcessEnv interface is the way to type the specific variables, and the validation is the runtime check
The fs module has the callback and the Promise APIs — the callback’s error is the NodeJS.ErrnoException | null, and the Promise’s return is the Promise<T>
The stream module has the Readable, the Writable, the Duplex, and the Transform — the TransformCallback is the custom stream’s callback’s type
The http module has the IncomingMessage and the ServerResponse — the Express’s Request and Response are the wrappers that the @types/express provides
The Express’s Request is generic over the params, the response’s body, the request’s body, and the query — the defaults are any, and the precise is the mission
The path module’s methods return the string — the join, the resolve, the basename, and the extname are the simple and the cross-platform
The declare module 'express' augments the Express’s Request — the declare global augments the NodeJS.ProcessEnv, and the export {} makes the file a module
The environment variables’ validation is the runtime check — the augmentation is the compile-time claim, and the check is the safety

Remember: The @types/node is the foundation of every TypeScript Node.js project. It contains the declarations for the built-in modules, and it is a development-only dependency. The process.env is typed as Record<string, string | undefined>, and the augmentation types the specific variables. The Express’s Request is generic, and the precise is the safety. The fs, the stream, the http, and the path have the types, and the @types/node is the source. The types are the compiler’s, and the validation is the runtime’s.

Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!

What @types/node is

The process.env typing

The fs module typing

The stream module typing

The http module typing

The path module typing

Complete Example Session

Quick Reference

The @types/node

The process.env

The fs Module

The stream Module

The http Module