msw 0.24.0 → 0.24.4

package/lib/iife/mockServiceWorker.js

@@ -0,0 +1,241 @@
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ * - Please do NOT serve this file on production.
+ */
+/* eslint-disable */
+/* tslint:disable */
+
+const INTEGRITY_CHECKSUM = '65d33ca82955e1c5928aed19d1bdf3f9'
+const bypassHeaderName = 'x-msw-bypass'
+
+let clients = {}
+
+self.addEventListener('install', function () {
+  return self.skipWaiting()
+})
+
+self.addEventListener('activate', async function (event) {
+  return self.clients.claim()
+})
+
+self.addEventListener('message', async function (event) {
+  const clientId = event.source.id
+  const client = await event.currentTarget.clients.get(clientId)
+  const allClients = await self.clients.matchAll()
+  const allClientIds = allClients.map((client) => client.id)
+
+  switch (event.data) {
+    case 'KEEPALIVE_REQUEST': {
+      sendToClient(client, {
+        type: 'KEEPALIVE_RESPONSE',
+      })
+      break
+    }
+
+    case 'INTEGRITY_CHECK_REQUEST': {
+      sendToClient(client, {
+        type: 'INTEGRITY_CHECK_RESPONSE',
+        payload: INTEGRITY_CHECKSUM,
+      })
+      break
+    }
+
+    case 'MOCK_ACTIVATE': {
+      clients = ensureKeys(allClientIds, clients)
+      clients[clientId] = true
+
+      sendToClient(client, {
+        type: 'MOCKING_ENABLED',
+        payload: true,
+      })
+      break
+    }
+
+    case 'MOCK_DEACTIVATE': {
+      clients = ensureKeys(allClientIds, clients)
+      clients[clientId] = false
+      break
+    }
+
+    case 'CLIENT_CLOSED': {
+      const remainingClients = allClients.filter((client) => {
+        return client.id !== clientId
+      })
+
+      // Unregister itself when there are no more clients
+      if (remainingClients.length === 0) {
+        self.registration.unregister()
+      }
+
+      break
+    }
+  }
+})
+
+self.addEventListener('fetch', function (event) {
+  const { clientId, request } = event
+  const requestClone = request.clone()
+  const getOriginalResponse = () => fetch(requestClone)
+
+  // Bypass navigation requests.
+  if (request.mode === 'navigate') {
+    return
+  }
+
+  // Bypass mocking if the current client isn't present in the internal clients map
+  // (i.e. has the mocking disabled).
+  if (!clients[clientId]) {
+    return
+  }
+
+  // Opening the DevTools triggers the "only-if-cached" request
+  // that cannot be handled by the worker. Bypass such requests.
+  if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+    return
+  }
+
+  event.respondWith(
+    new Promise(async (resolve, reject) => {
+      const client = await event.target.clients.get(clientId)
+
+      // Bypass mocking when the request client is not active.
+      if (!client) {
+        return resolve(getOriginalResponse())
+      }
+
+      // Bypass requests with the explicit bypass header
+      if (requestClone.headers.get(bypassHeaderName) === 'true') {
+        const modifiedHeaders = serializeHeaders(requestClone.headers)
+
+        // Remove the bypass header to comply with the CORS preflight check
+        delete modifiedHeaders[bypassHeaderName]
+
+        const originalRequest = new Request(requestClone, {
+          headers: new Headers(modifiedHeaders),
+        })
+
+        return resolve(fetch(originalRequest))
+      }
+
+      const reqHeaders = serializeHeaders(request.headers)
+      const body = await request.text()
+
+      const rawClientMessage = await sendToClient(client, {
+        type: 'REQUEST',
+        payload: {
+          url: request.url,
+          method: request.method,
+          headers: reqHeaders,
+          cache: request.cache,
+          mode: request.mode,
+          credentials: request.credentials,
+          destination: request.destination,
+          integrity: request.integrity,
+          redirect: request.redirect,
+          referrer: request.referrer,
+          referrerPolicy: request.referrerPolicy,
+          body,
+          bodyUsed: request.bodyUsed,
+          keepalive: request.keepalive,
+        },
+      })
+
+      const clientMessage = rawClientMessage
+
+      switch (clientMessage.type) {
+        case 'MOCK_SUCCESS': {
+          setTimeout(
+            resolve.bind(this, createResponse(clientMessage)),
+            clientMessage.payload.delay,
+          )
+          break
+        }
+
+        case 'MOCK_NOT_FOUND': {
+          return resolve(getOriginalResponse())
+        }
+
+        case 'NETWORK_ERROR': {
+          const { name, message } = clientMessage.payload
+          const networkError = new Error(message)
+          networkError.name = name
+
+          // Rejecting a request Promise emulates a network error.
+          return reject(networkError)
+        }
+
+        case 'INTERNAL_ERROR': {
+          const parsedBody = JSON.parse(clientMessage.payload.body)
+
+          console.error(
+            `\
+[MSW] Request handler function for "%s %s" has thrown the following exception:
+
+${parsedBody.errorType}: ${parsedBody.message}
+(see more detailed error stack trace in the mocked response body)
+
+This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error.
+If you wish to mock an error response, please refer to this guide: https://mswjs.io/docs/recipes/mocking-error-responses\
+  `,
+            request.method,
+            request.url,
+          )
+
+          return resolve(createResponse(clientMessage))
+        }
+      }
+    }).catch((error) => {
+      console.error(
+        '[MSW] Failed to mock a "%s" request to "%s": %s',
+        request.method,
+        request.url,
+        error,
+      )
+    }),
+  )
+})
+
+function serializeHeaders(headers) {
+  const reqHeaders = {}
+  headers.forEach((value, name) => {
+    reqHeaders[name] = reqHeaders[name]
+      ? [].concat(reqHeaders[name]).concat(value)
+      : value
+  })
+  return reqHeaders
+}
+
+function sendToClient(client, message) {
+  return new Promise((resolve, reject) => {
+    const channel = new MessageChannel()
+
+    channel.port1.onmessage = (event) => {
+      if (event.data && event.data.error) {
+        reject(event.data.error)
+      } else {
+        resolve(event.data)
+      }
+    }
+
+    client.postMessage(JSON.stringify(message), [channel.port2])
+  })
+}
+
+function createResponse(clientMessage) {
+  return new Response(clientMessage.payload.body, {
+    ...clientMessage.payload,
+    headers: clientMessage.payload.headers,
+  })
+}
+
+function ensureKeys(keys, obj) {
+  return Object.keys(obj).reduce((acc, key) => {
+    if (keys.includes(key)) {
+      acc[key] = obj[key]
+    }
+
+    return acc
+  }, {})
+}

package/lib/types/context/body.d.ts

@@ -1,7 +1,9 @@
 import { ResponseTransformer } from '../response';
 /**
- * Sets the body of the response without any `Content-Type` header.
+ * Sets a raw response body. Does not append any `Content-Type` headers.
  * @example
- * res(body('message'))
+ * res(ctx.body('Successful response'))
+ * res(ctx.body(JSON.stringify({ key: 'value' })))
+ * @see {@link https://mswjs.io/docs/api/context/body `ctx.body()`}
  */
 export declare const body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => ResponseTransformer<BodyType>;

package/lib/types/context/cookie.d.ts

@@ -1,8 +1,7 @@
 import * as cookieUtils from 'cookie';
 import { ResponseTransformer } from '../response';
 /**
- * Sets a given cookie on the response.
- * @example
- * res(cookie('name', 'value'))
+ * Sets a given cookie on the mocked response.
+ * @example res(ctx.cookie('name', 'value'))
  */
 export declare const cookie: (name: string, value: string, options?: cookieUtils.CookieSerializeOptions | undefined) => ResponseTransformer;

package/lib/types/context/data.d.ts

@@ -1,6 +1,8 @@
 import { ResponseTransformer } from '../response';
-export declare type DataContext<T> = (payload: T) => ResponseTransformer;
 /**
- * Returns a GraphQL body payload.
+ * Sets a given payload as a GraphQL response body.
+ * @example
+ * res(ctx.data({ user: { firstName: 'John' }}))
+ * @see {@link https://mswjs.io/docs/api/context/data `ctx.data()`}
  */
-export declare const data: DataContext<Record<string, any>>;
+export declare const data: <T extends Record<string, any>>(payload: T) => ResponseTransformer;

package/lib/types/context/delay.d.ts

@@ -3,9 +3,10 @@ export declare const MIN_SERVER_RESPONSE_TIME = 100;
 export declare const MAX_SERVER_RESPONSE_TIME = 400;
 export declare const NODE_SERVER_RESPONSE_TIME = 5;
 /**
- * Delays the current response for the given duration (in ms)
+ * Delays the response by the given duration (ms).
  * @example
- * res(delay()) // realistic server response time
- * res(delay(1500)) // explicit response delay duration
+ * res(ctx.delay()) // realistic server response time
+ * res(ctx.delay(1200))
+ * @see {@link https://mswjs.io/docs/api/context/delay `ctx.delay()`}
  */
 export declare const delay: (durationMs?: number | undefined) => ResponseTransformer;

package/lib/types/context/errors.d.ts

@@ -2,5 +2,7 @@ import { GraphQLError } from 'graphql';
 import { ResponseTransformer } from '../response';
 /**
  * Sets a given list of GraphQL errors on the mocked response.
+ * @example res(ctx.errors([{ message: 'Unauthorized' }]))
+ * @see {@link https://mswjs.io/docs/api/context/errors}
  */
 export declare const errors: <ErrorsType extends Partial<GraphQLError>[] | null | undefined>(errorsList: ErrorsType) => ResponseTransformer<string>;

package/lib/types/context/fetch.d.ts

@@ -1,8 +1,9 @@
 import { MockedRequest } from '../utils/handlers/requestHandler';
 export declare const augmentRequestInit: (requestInit: RequestInit) => RequestInit;
 /**
- * Wrapper around the native `window.fetch()` function that performs
- * a request bypassing MSW. Requests performed using
- * this function will never be mocked.
+ * Performs a bypassed request inside a request handler.
+ * @example
+ * const originalResponse = await ctx.fetch(req)
+ * @see {@link https://mswjs.io/docs/api/context/fetch `ctx.fetch()`}
  */
 export declare const fetch: (input: string | MockedRequest, requestInit?: RequestInit) => any;

package/lib/types/context/json.d.ts

@@ -1,9 +1,12 @@
 import { ResponseTransformer } from '../response';
 /**
  * Sets the given value as the JSON body of the response.
+ * Appends a `Content-Type: application/json` header on the
+ * mocked response.
  * @example
- * res(json({ key: 'value' }))
- * res(json('Some string'))
- * res(json([1, '2', false, { ok: true }]))
+ * res(ctx.json('Some string'))
+ * res(ctx.json({ key: 'value' }))
+ * res(ctx.json([1, '2', false, { ok: true }]))
+ * @see {@link https://mswjs.io/docs/api/context/json `ctx.json()`}
  */
 export declare const json: <BodyTypeJSON>(body: BodyTypeJSON) => ResponseTransformer<string>;

package/lib/types/context/set.d.ts

@@ -1,2 +1,6 @@
 import { ResponseTransformer } from '../response';
+/**
+ * Sets one or multiple response headers.
+ * @see {@link https://mswjs.io/docs/api/context/set `ctx.set()`}
+ */
 export declare function set<N extends string | Record<string, string | string[]>>(...args: N extends string ? [N, string] : [N]): ResponseTransformer;

package/lib/types/context/status.d.ts

@@ -1,2 +1,9 @@
 import { ResponseTransformer } from '../response';
+/**
+ * Sets a response status code and text.
+ * @example
+ * res(ctx.status(301))
+ * res(ctx.status(400, 'Custom status text'))
+ * @see {@link https://mswjs.io/docs/api/context/status `ctx.status()`}
+ */
 export declare const status: (statusCode: number, statusText?: string | undefined) => ResponseTransformer;

package/lib/types/context/text.d.ts

@@ -1,7 +1,8 @@
 import { ResponseTransformer } from '../response';
 /**
- * Sets a given text as a "Cotent-Type: text/plain" body of the response.
- * @example
- * res(text('message'))
+ * Sets a textual response body. Appends a `Content-Type: text/plain`
+ * header on the mocked response.
+ * @example res(ctx.text('Successful response'))
+ * @see {@link https://mswjs.io/docs/api/context/text `ctx.text()`}
  */
 export declare const text: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType>;

package/lib/types/context/xml.d.ts

@@ -1,7 +1,9 @@
 import { ResponseTransformer } from '../response';
 /**
- * Sets the given XML as the body of the response.
+ * Sets an XML response body. Appends a `Content-Type: text/xml` header
+ * on the mocked response.
  * @example
- * res(xml('<key>value</key>'))
+ * res(ctx.xml('<node key="value">Content</node>'))
+ * @see {@link https://mswjs.io/docs/api/context/xml `ctx.xml()`}
  */
 export declare const xml: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType>;

package/lib/types/graphql.d.ts

@@ -6,23 +6,23 @@ import { set } from './context/set';
 import { status } from './context/status';
 import { delay } from './context/delay';
 import { fetch } from './context/fetch';
-import { DataContext } from './context/data';
+import { data } from './context/data';
 import { errors } from './context/errors';
 declare type GraphQLRequestHandlerSelector = RegExp | string;
 export declare type GraphQLMockedRequest<VariablesType = Record<string, any>> = Omit<MockedRequest, 'body'> & {
     body: (GraphQLRequestPayload<VariablesType> & Record<string, any>) | undefined;
     variables: VariablesType;
 };
-export interface GraphQLMockedContext<QueryType> {
+export interface GraphQLMockedContext {
     set: typeof set;
     status: typeof status;
     delay: typeof delay;
     fetch: typeof fetch;
-    data: DataContext<QueryType>;
+    data: typeof data;
     errors: typeof errors;
 }
-export declare const graphqlContext: GraphQLMockedContext<any>;
-export declare type GraphQLResponseResolver<QueryType, VariablesType> = (req: GraphQLMockedRequest<VariablesType>, res: ResponseComposition, context: GraphQLMockedContext<QueryType>) => AsyncResponseResolverReturnType<MockedResponse>;
+export declare const graphqlContext: GraphQLMockedContext;
+export declare type GraphQLResponseResolver<QueryType, VariablesType> = (req: GraphQLMockedRequest<VariablesType>, res: ResponseComposition<any>, context: GraphQLMockedContext) => AsyncResponseResolverReturnType<MockedResponse>;
 export interface GraphQLRequestPayload<VariablesType> {
     query: string;
     variables?: VariablesType;
@@ -33,15 +33,71 @@ export interface GraphQLRequestParsedResult<VariablesType> {
     variables: VariablesType | undefined;
 }
 declare const graphqlStandardHandlers: {
-    operation: <QueryType, VariablesType = Record<string, any>>(resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>, any>;
-    query: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
-    mutation: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
+    /**
+     * Captures any GraphQL operation, regardless of its name, under the current scope.
+     * @example
+     * graphql.operation((req, res, ctx) => {
+     *   return res(ctx.data({ name: 'John' }))
+     * })
+     * @see {@link https://mswjs.io/docs/api/graphql/operation `graphql.operation()`}
+     */
+    operation: <QueryType, VariablesType = Record<string, any>>(resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>, any>;
+    /**
+     * Captures a GraphQL query by a given name.
+     * @example
+     * graphql.query('GetUser', (req, res, ctx) => {
+     *   return res(ctx.data({ user: { name: 'John' } }))
+     * })
+     * @see {@link https://mswjs.io/docs/api/graphql/query `graphql.query()`}
+     */
+    query: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
+    /**
+     * Captures a GraphQL mutation by a given name.
+     * @example
+     * graphql.mutation('SavePost', (req, res, ctx) => {
+     *   return res(ctx.data({ post: { id: 'abc-123' } }))
+     * })
+     * @see {@link https://mswjs.io/docs/api/graphql/mutation `graphql.mutation()`}
+     */
+    mutation: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
 };
+/**
+ * Creates a GraphQL mocking API scoped to the given endpoint.
+ * @param uri Endpoint URL, or path.
+ * @example
+ * const api = graphql.link('https://api.site.com/graphql)
+ * api.query('GetUser', resolver)
+ * @see {@link https://mswjs.io/docs/api/graphql/link `graphql.link()`}
+ */
 declare function createGraphQLLink(uri: Mask): typeof graphqlStandardHandlers;
 export declare const graphql: {
     link: typeof createGraphQLLink;
-    operation: <QueryType, VariablesType = Record<string, any>>(resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>, any>;
-    query: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
-    mutation: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
+    /**
+     * Captures any GraphQL operation, regardless of its name, under the current scope.
+     * @example
+     * graphql.operation((req, res, ctx) => {
+     *   return res(ctx.data({ name: 'John' }))
+     * })
+     * @see {@link https://mswjs.io/docs/api/graphql/operation `graphql.operation()`}
+     */
+    operation: <QueryType, VariablesType = Record<string, any>>(resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>, any>;
+    /**
+     * Captures a GraphQL query by a given name.
+     * @example
+     * graphql.query('GetUser', (req, res, ctx) => {
+     *   return res(ctx.data({ user: { name: 'John' } }))
+     * })
+     * @see {@link https://mswjs.io/docs/api/graphql/query `graphql.query()`}
+     */
+    query: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
+    /**
+     * Captures a GraphQL mutation by a given name.
+     * @example
+     * graphql.mutation('SavePost', (req, res, ctx) => {
+     *   return res(ctx.data({ post: { id: 'abc-123' } }))
+     * })
+     * @see {@link https://mswjs.io/docs/api/graphql/mutation `graphql.mutation()`}
+     */
+    mutation: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
 };
 export {};

package/lib/types/index.d.ts

@@ -4,7 +4,7 @@ export { SetupWorkerApi } from './setupWorker/glossary';
 export { response, defaultResponse, createResponseComposition, MockedResponse, ResponseTransformer, ResponseComposition, ResponseCompositionOptions, ResponseFunction, } from './response';
 export { context };
 export { defaultContext, MockedRequest, RequestHandler, RequestHandlerMetaInfo, RequestParams, RequestQuery, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, } from './utils/handlers/requestHandler';
-export { rest, restContext, RESTMethods, ParsedRestRequest } from './rest';
+export { rest, restContext, RestContext, RESTMethods, ParsedRestRequest, } from './rest';
 export { graphql, graphqlContext, GraphQLMockedRequest, GraphQLMockedContext, GraphQLRequestPayload, GraphQLResponseResolver, GraphQLRequestParsedResult, } from './graphql';
 export { matchRequestUrl } from './utils/matching/matchRequestUrl';
 export { compose } from './utils/internal/compose';

package/lib/types/node/glossary.d.ts

@@ -2,27 +2,33 @@ import { SharedOptions } from '../sharedOptions';
 import { RequestHandlersList } from '../setupWorker/glossary';
 export interface SetupServerApi {
     /**
-     * Enables requests interception based on the previously provided mock definition.
+     * Starts requests interception based on the previously provided request handlers.
+     * @see {@link https://mswjs.io/docs/api/setup-server/listen `server.listen()`}
      */
     listen: (options?: SharedOptions) => void;
+    /**
+     * Stops requests interception by restoring all augmented modules.
+     * @see {@link https://mswjs.io/docs/api/setup-server/close `server.close()`}
+     */
+    close: () => void;
     /**
      * Prepends given request handlers to the list of existing handlers.
+     * @see {@link https://mswjs.io/docs/api/setup-server/use `server.use()`}
      */
     use: (...handlers: RequestHandlersList) => void;
     /**
      * Marks all request handlers that respond using `res.once()` as unused.
+     * @see {@link https://mswjs.io/docs/api/setup-server/restore-handlers `server.restore-handlers()`}
      */
     restoreHandlers: () => void;
     /**
      * Resets request handlers to the initial list given to the `setupServer` call, or to the explicit next request handlers list, if given.
+     * @see {@link https://mswjs.io/docs/api/setup-server/reset-handlers `server.reset-handlers()`}
      */
     resetHandlers: (...nextHandlers: RequestHandlersList) => void;
     /**
      * Lists all active request handlers.
+     * @see {@link https://mswjs.io/docs/api/setup-server/print-handlers `server.print-handlers()`}
      */
     printHandlers: () => void;
-    /**
-     * Stops requests interception by restoring all augmented modules.
-     */
-    close: () => void;
 }

package/lib/types/node/setupServer.d.ts

@@ -1 +1,6 @@
+/**
+ * Sets up a requests interception in NodeJS with the given request handlers.
+ * @param {RequestHandler[]} requestHandlers List of request handlers.
+ * @see {@link https://mswjs.io/docs/api/setup-server `setupServer`}
+ */
 export declare const setupServer: (...requestHandlers: import("../setupWorker/glossary").RequestHandlersList) => import("./glossary").SetupServerApi;