msw 2.15.0 → 3.0.0

package/lib/_chunks/http-response.js

@@ -0,0 +1,137 @@
+import { d as normalizeResponseInit, l as decorateResponse } from "./cookie-store.js";
+import { n as kDefaultContentType, t as bodyType } from "./symbols.js";
+import { FetchResponse } from "@mswjs/interceptors";
+//#region src/http/http-response.ts
+/**
+* A drop-in replacement for the standard `Response` class
+* to allow additional features, like mocking the response `Set-Cookie` header.
+*
+* @example
+* new HttpResponse('Hello world', { status: 201 })
+* HttpResponse.json({ name: 'John' })
+* HttpResponse.formData(form)
+*
+* @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
+*/
+var HttpResponse = class HttpResponse extends FetchResponse {
+	[bodyType] = null;
+	constructor(body, init) {
+		const responseInit = normalizeResponseInit(init);
+		super(body, responseInit);
+		decorateResponse(this, responseInit);
+	}
+	static error() {
+		return super.error();
+	}
+	/**
+	* Create a `Response` with a `Content-Type: "text/plain"` body.
+	* @example
+	* HttpResponse.text('hello world')
+	* HttpResponse.text('Error', { status: 500 })
+	*/
+	static text(body, init) {
+		const responseInit = normalizeResponseInit(init);
+		const hasExplicitContentType = responseInit.headers.has("Content-Type");
+		if (!hasExplicitContentType) responseInit.headers.set("Content-Type", "text/plain");
+		if (!responseInit.headers.has("Content-Length")) responseInit.headers.set("Content-Length", body ? new Blob([body]).size.toString() : "0");
+		const response = new HttpResponse(body, responseInit);
+		if (!hasExplicitContentType) Object.defineProperty(response, kDefaultContentType, {
+			value: true,
+			enumerable: false
+		});
+		return response;
+	}
+	/**
+	* Create a `Response` with a `Content-Type: "application/json"` body.
+	* @example
+	* HttpResponse.json({ firstName: 'John' })
+	* HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+	*/
+	static json(body, init) {
+		const responseInit = normalizeResponseInit(init);
+		const hasExplicitContentType = responseInit.headers.has("Content-Type");
+		if (!hasExplicitContentType) responseInit.headers.set("Content-Type", "application/json");
+		/**
+		* @note TypeScript is incorrect here.
+		* Stringifying undefined will return undefined.
+		*/
+		const responseText = JSON.stringify(body);
+		if (!responseInit.headers.has("Content-Length")) responseInit.headers.set("Content-Length", responseText ? new Blob([responseText]).size.toString() : "0");
+		const response = new HttpResponse(responseText, responseInit);
+		if (!hasExplicitContentType) Object.defineProperty(response, kDefaultContentType, {
+			value: true,
+			enumerable: false
+		});
+		return response;
+	}
+	/**
+	* Create a `Response` with a `Content-Type: "application/xml"` body.
+	* @example
+	* HttpResponse.xml(`<user name="John" />`)
+	* HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+	*/
+	static xml(body, init) {
+		const responseInit = normalizeResponseInit(init);
+		const hasExplicitContentType = responseInit.headers.has("Content-Type");
+		if (!hasExplicitContentType) responseInit.headers.set("Content-Type", "text/xml");
+		const response = new HttpResponse(body, responseInit);
+		if (!hasExplicitContentType) Object.defineProperty(response, kDefaultContentType, {
+			value: true,
+			enumerable: false
+		});
+		return response;
+	}
+	/**
+	* Create a `Response` with a `Content-Type: "text/html"` body.
+	* @example
+	* HttpResponse.html(`<p class="author">Jane Doe</p>`)
+	* HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
+	*/
+	static html(body, init) {
+		const responseInit = normalizeResponseInit(init);
+		const hasExplicitContentType = responseInit.headers.has("Content-Type");
+		if (!hasExplicitContentType) responseInit.headers.set("Content-Type", "text/html");
+		const response = new HttpResponse(body, responseInit);
+		if (!hasExplicitContentType) Object.defineProperty(response, kDefaultContentType, {
+			value: true,
+			enumerable: false
+		});
+		return response;
+	}
+	/**
+	* Create a `Response` with an `ArrayBuffer` body.
+	* @example
+	* const buffer = new ArrayBuffer(3)
+	* const view = new Uint8Array(buffer)
+	* view.set([1, 2, 3])
+	*
+	* HttpResponse.arrayBuffer(buffer)
+	*/
+	static arrayBuffer(body, init) {
+		const responseInit = normalizeResponseInit(init);
+		const hasExplicitContentType = responseInit.headers.has("Content-Type");
+		if (!hasExplicitContentType) responseInit.headers.set("Content-Type", "application/octet-stream");
+		if (body && !responseInit.headers.has("Content-Length")) responseInit.headers.set("Content-Length", body.byteLength.toString());
+		const response = new HttpResponse(body, responseInit);
+		if (!hasExplicitContentType) Object.defineProperty(response, kDefaultContentType, {
+			value: true,
+			enumerable: false
+		});
+		return response;
+	}
+	/**
+	* Create a `Response` with a `FormData` body.
+	* @example
+	* const data = new FormData()
+	* data.set('name', 'Alice')
+	*
+	* HttpResponse.formData(data)
+	*/
+	static formData(body, init) {
+		return new HttpResponse(body, normalizeResponseInit(init));
+	}
+};
+//#endregion
+export { HttpResponse as t };
+
+//# sourceMappingURL=http-response.js.map

package/lib/_chunks/http-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-response.js","names":[],"sources":["../../src/http/http-response.ts"],"sourcesContent":["import { FetchResponse } from '@mswjs/interceptors'\nimport type {\n  DefaultBodyType,\n  JsonBodyType,\n} from '#core/handlers/request-handler'\nimport type { TransparentNoInfer } from '#core/type-utils'\nimport {\n  decorateResponse,\n  normalizeResponseInit,\n} from '#core/utils/response-decorators'\nimport { kDefaultContentType, bodyType } from './symbols'\n\nexport { kDefaultContentType }\n\nexport interface HttpResponseInit extends ResponseInit {\n  type?: ResponseType\n}\n\nexport type DefaultUnsafeFetchResponse = Response & {\n  [bodyType]?: never\n}\n\nexport interface StrictRequest<BodyType extends JsonBodyType> extends Request {\n  json(): Promise<BodyType>\n  clone(): StrictRequest<BodyType>\n}\n\n/**\n * A drop-in replacement for the standard `Response` class\n * to allow additional features, like mocking the response `Set-Cookie` header.\n *\n * @example\n * new HttpResponse('Hello world', { status: 201 })\n * HttpResponse.json({ name: 'John' })\n * HttpResponse.formData(form)\n *\n * @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}\n */\nexport class HttpResponse<\n  BodyType extends DefaultBodyType,\n> extends FetchResponse {\n  readonly [bodyType]: BodyType = null as any\n\n  constructor(\n    body?: TransparentNoInfer<BodyType> | null,\n    init?: HttpResponseInit,\n  ) {\n    const responseInit = normalizeResponseInit(init)\n    super(body as BodyInit, responseInit)\n    decorateResponse(this, responseInit)\n  }\n\n  static error(): HttpResponse<any> {\n    return super.error() as HttpResponse<any>\n  }\n\n  /**\n   * Create a `Response` with a `Content-Type: \"text/plain\"` body.\n   * @example\n   * HttpResponse.text('hello world')\n   * HttpResponse.text('Error', { status: 500 })\n   */\n  static text<BodyType extends string>(\n    body?: TransparentNoInfer<BodyType> | null,\n    init?: HttpResponseInit,\n  ): HttpResponse<BodyType> {\n    const responseInit = normalizeResponseInit(init)\n    const hasExplicitContentType = responseInit.headers.has('Content-Type')\n\n    if (!hasExplicitContentType) {\n      responseInit.headers.set('Content-Type', 'text/plain')\n    }\n\n    // Automatically set the \"Content-Length\" response header\n    // for non-empty text responses. This enforces consistency and\n    // brings mocked responses closer to production.\n    if (!responseInit.headers.has('Content-Length')) {\n      responseInit.headers.set(\n        'Content-Length',\n        body ? new Blob([body]).size.toString() : '0',\n      )\n    }\n\n    const response = new HttpResponse(body, responseInit)\n\n    if (!hasExplicitContentType) {\n      Object.defineProperty(response, kDefaultContentType, {\n        value: true,\n        enumerable: false,\n      })\n    }\n\n    return response\n  }\n\n  /**\n   * Create a `Response` with a `Content-Type: \"application/json\"` body.\n   * @example\n   * HttpResponse.json({ firstName: 'John' })\n   * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })\n   */\n  static json<BodyType extends JsonBodyType>(\n    body?: TransparentNoInfer<BodyType> | null | undefined,\n    init?: HttpResponseInit,\n  ): HttpResponse<BodyType> {\n    const responseInit = normalizeResponseInit(init)\n    const hasExplicitContentType = responseInit.headers.has('Content-Type')\n\n    if (!hasExplicitContentType) {\n      responseInit.headers.set('Content-Type', 'application/json')\n    }\n\n    /**\n     * @note TypeScript is incorrect here.\n     * Stringifying undefined will return undefined.\n     */\n    const responseText = JSON.stringify(body) as string | undefined\n\n    if (!responseInit.headers.has('Content-Length')) {\n      responseInit.headers.set(\n        'Content-Length',\n        responseText ? new Blob([responseText]).size.toString() : '0',\n      )\n    }\n\n    const response = new HttpResponse(responseText, responseInit)\n\n    if (!hasExplicitContentType) {\n      Object.defineProperty(response, kDefaultContentType, {\n        value: true,\n        enumerable: false,\n      })\n    }\n\n    return response as HttpResponse<BodyType>\n  }\n\n  /**\n   * Create a `Response` with a `Content-Type: \"application/xml\"` body.\n   * @example\n   * HttpResponse.xml(`<user name=\"John\" />`)\n   * HttpResponse.xml(`<article id=\"abc-123\" />`, { status: 201 })\n   */\n  static xml<BodyType extends string>(\n    body?: BodyType | null,\n    init?: HttpResponseInit,\n  ): HttpResponse<BodyType> {\n    const responseInit = normalizeResponseInit(init)\n    const hasExplicitContentType = responseInit.headers.has('Content-Type')\n\n    if (!hasExplicitContentType) {\n      responseInit.headers.set('Content-Type', 'text/xml')\n    }\n\n    const response = new HttpResponse(body, responseInit)\n\n    if (!hasExplicitContentType) {\n      Object.defineProperty(response, kDefaultContentType, {\n        value: true,\n        enumerable: false,\n      })\n    }\n\n    return response as HttpResponse<BodyType>\n  }\n\n  /**\n   * Create a `Response` with a `Content-Type: \"text/html\"` body.\n   * @example\n   * HttpResponse.html(`<p class=\"author\">Jane Doe</p>`)\n   * HttpResponse.html(`<main id=\"abc-123\">Main text</main>`, { status: 201 })\n   */\n  static html<BodyType extends string>(\n    body?: BodyType | null,\n    init?: HttpResponseInit,\n  ): HttpResponse<BodyType> {\n    const responseInit = normalizeResponseInit(init)\n    const hasExplicitContentType = responseInit.headers.has('Content-Type')\n\n    if (!hasExplicitContentType) {\n      responseInit.headers.set('Content-Type', 'text/html')\n    }\n\n    const response = new HttpResponse(body, responseInit)\n\n    if (!hasExplicitContentType) {\n      Object.defineProperty(response, kDefaultContentType, {\n        value: true,\n        enumerable: false,\n      })\n    }\n\n    return response as HttpResponse<BodyType>\n  }\n\n  /**\n   * Create a `Response` with an `ArrayBuffer` body.\n   * @example\n   * const buffer = new ArrayBuffer(3)\n   * const view = new Uint8Array(buffer)\n   * view.set([1, 2, 3])\n   *\n   * HttpResponse.arrayBuffer(buffer)\n   */\n  static arrayBuffer<BodyType extends ArrayBuffer | SharedArrayBuffer>(\n    body?: BodyType,\n    init?: HttpResponseInit,\n  ): HttpResponse<BodyType> {\n    const responseInit = normalizeResponseInit(init)\n    const hasExplicitContentType = responseInit.headers.has('Content-Type')\n\n    if (!hasExplicitContentType) {\n      responseInit.headers.set('Content-Type', 'application/octet-stream')\n    }\n\n    if (body && !responseInit.headers.has('Content-Length')) {\n      responseInit.headers.set('Content-Length', body.byteLength.toString())\n    }\n\n    const response = new HttpResponse(body, responseInit)\n\n    if (!hasExplicitContentType) {\n      Object.defineProperty(response, kDefaultContentType, {\n        value: true,\n        enumerable: false,\n      })\n    }\n\n    return response as HttpResponse<BodyType>\n  }\n\n  /**\n   * Create a `Response` with a `FormData` body.\n   * @example\n   * const data = new FormData()\n   * data.set('name', 'Alice')\n   *\n   * HttpResponse.formData(data)\n   */\n  static formData(\n    body?: FormData,\n    init?: HttpResponseInit,\n  ): HttpResponse<FormData> {\n    return new HttpResponse(body, normalizeResponseInit(init))\n  }\n}\n"],"mappings":"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"}

package/lib/{core → _chunks}/http.d.ts

@@ -1,11 +1,7 @@
-import { D as DefaultBodyType, l as ResponseResolver, j as RequestHandlerOptions } from './HttpResponse-DL-P1EeG.js';
-import { HttpRequestPredicate, HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
-import { PathParams } from './utils/matching/matchRequestUrl.js';
-import '@mswjs/interceptors';
-import './utils/internal/isIterable.js';
-import './typeUtils.js';
-import 'graphql';
-
+import { c as RequestHandlerOptions, l as ResponseResolver, n as DefaultBodyType } from "./request-handler.js";
+import { r as PathParams } from "./match-request-url.js";
+import { c as HttpRequestResolverExtras, n as HttpHandler, s as HttpRequestPredicate } from "./http-handler.js";
+//#region src/http/http.d.ts
 type HttpRequestHandler = <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(predicate: HttpRequestPredicate<Params>, resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>, options?: RequestHandlerOptions) => HttpHandler;
 type HttpResponseResolver<Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = DefaultBodyType> = ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>;
 /**
@@ -18,14 +14,15 @@ type HttpResponseResolver<Params extends PathParams<keyof Params> = PathParams,
  * @see {@link https://mswjs.io/docs/api/http `http` API reference}
  */
 declare const http: {
-    all: HttpRequestHandler;
-    head: HttpRequestHandler;
-    get: HttpRequestHandler;
-    post: HttpRequestHandler;
-    put: HttpRequestHandler;
-    delete: HttpRequestHandler;
-    patch: HttpRequestHandler;
-    options: HttpRequestHandler;
+  all: HttpRequestHandler;
+  head: HttpRequestHandler;
+  get: HttpRequestHandler;
+  post: HttpRequestHandler;
+  put: HttpRequestHandler;
+  delete: HttpRequestHandler;
+  patch: HttpRequestHandler;
+  options: HttpRequestHandler;
 };
-
-export { type HttpRequestHandler, type HttpResponseResolver, http };
+//#endregion
+export { HttpResponseResolver as n, http as r, HttpRequestHandler as t };
+//# sourceMappingURL=http.d.ts.map

package/lib/_chunks/http.js

@@ -0,0 +1,30 @@
+import { t as HttpHandler } from "./http-handler.js";
+//#region src/http/http.ts
+function createHttpHandler(method) {
+	return (predicate, resolver, options = {}) => {
+		return new HttpHandler(method, predicate, resolver, options);
+	};
+}
+/**
+* A namespace to intercept and mock HTTP requests.
+*
+* @example
+* http.get('/user', resolver)
+* http.post('/post/:id', resolver)
+*
+* @see {@link https://mswjs.io/docs/api/http `http` API reference}
+*/
+const http = {
+	all: createHttpHandler(/.+/),
+	head: createHttpHandler("HEAD"),
+	get: createHttpHandler("GET"),
+	post: createHttpHandler("POST"),
+	put: createHttpHandler("PUT"),
+	delete: createHttpHandler("DELETE"),
+	patch: createHttpHandler("PATCH"),
+	options: createHttpHandler("OPTIONS")
+};
+//#endregion
+export { http as t };
+
+//# sourceMappingURL=http.js.map

package/lib/_chunks/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","names":[],"sources":["../../src/http/http.ts"],"sourcesContent":["import type {\n  DefaultBodyType,\n  RequestHandlerOptions,\n  ResponseResolver,\n} from '#core/handlers/request-handler'\nimport {\n  HttpMethods,\n  HttpHandler,\n  type HttpRequestResolverExtras,\n  type HttpRequestPredicate,\n} from './http-handler'\nimport type { PathParams } from '#core/utils/matching/match-request-url'\n\nexport type HttpRequestHandler = <\n  Params extends PathParams<keyof Params> = PathParams,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  // Response body type MUST be undefined by default.\n  // This is how we can distinguish between a handler that\n  // returns plain \"Response\" and the one returning \"HttpResponse\"\n  // to enforce a stricter response body type.\n  ResponseBodyType extends DefaultBodyType = undefined,\n>(\n  predicate: HttpRequestPredicate<Params>,\n  resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>,\n  options?: RequestHandlerOptions,\n) => HttpHandler\n\nexport type HttpResponseResolver<\n  Params extends PathParams<keyof Params> = PathParams,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  ResponseBodyType extends DefaultBodyType = DefaultBodyType,\n> = ResponseResolver<\n  HttpRequestResolverExtras<Params>,\n  RequestBodyType,\n  ResponseBodyType\n>\n\nfunction createHttpHandler<Method extends HttpMethods | RegExp>(\n  method: Method,\n): HttpRequestHandler {\n  return (predicate, resolver, options = {}) => {\n    return new HttpHandler(method, predicate, resolver, options)\n  }\n}\n\n/**\n * A namespace to intercept and mock HTTP requests.\n *\n * @example\n * http.get('/user', resolver)\n * http.post('/post/:id', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/http `http` API reference}\n */\nexport const http = {\n  all: createHttpHandler(/.+/),\n  head: createHttpHandler(HttpMethods.HEAD),\n  get: createHttpHandler(HttpMethods.GET),\n  post: createHttpHandler(HttpMethods.POST),\n  put: createHttpHandler(HttpMethods.PUT),\n  delete: createHttpHandler(HttpMethods.DELETE),\n  patch: createHttpHandler(HttpMethods.PATCH),\n  options: createHttpHandler(HttpMethods.OPTIONS),\n}\n"],"mappings":";;AAqCA,SAAS,kBACP,QACoB;CACpB,QAAQ,WAAW,UAAU,UAAU,CAAC,MAAM;EAC5C,OAAO,IAAI,YAAY,QAAQ,WAAW,UAAU,OAAO;CAC7D;AACF;;;;;;;;;;AAWA,MAAa,OAAO;CAClB,KAAK,kBAAkB,IAAI;CAC3B,MAAM,kBAAA,MAAkC;CACxC,KAAK,kBAAA,KAAiC;CACtC,MAAM,kBAAA,MAAkC;CACxC,KAAK,kBAAA,KAAiC;CACtC,QAAQ,kBAAA,QAAoC;CAC5C,OAAO,kBAAA,OAAmC;CAC1C,SAAS,kBAAA,SAAqC;AAChD"}

package/lib/_chunks/interceptor-source.d.ts

@@ -0,0 +1,163 @@
+import { a as RequestHandler, b as UnionToIntersection } from "./request-handler.js";
+import { _ as ExtractFrameEvents, b as UnhandledFrameHandle, g as AnyNetworkFrame, n as HandlersController, t as AnyHandler, v as NetworkFrame, y as NetworkFrameResolutionContext } from "./handlers-controller.js";
+import { HttpRequestEventMap, Interceptor } from "@mswjs/interceptors";
+import { DefaultEventMap, Emitter, TypedEvent, TypedListenerOptions } from "rettime";
+import { WebSocketEventMap } from "@mswjs/interceptors/WebSocket";
+//#region src/core/experimental/frames/http-frame.d.ts
+interface HttpNetworkFrameOptions {
+  id?: string;
+  request: Request;
+}
+declare class RequestEvent<DataType extends {
+  requestId: string;
+  request: Request;
+} = {
+  requestId: string;
+  request: Request;
+}, ReturnType = void, EventType extends string = string> extends TypedEvent<DataType, ReturnType, EventType> {
+  readonly requestId: string;
+  readonly request: Request;
+  constructor(type: EventType, data: DataType);
+}
+declare class ResponseEvent<DataType extends {
+  requestId: string;
+  request: Request;
+  response: Response;
+} = {
+  requestId: string;
+  request: Request;
+  response: Response;
+}, ReturnType = void, EventType extends string = string> extends TypedEvent<DataType, ReturnType, EventType> {
+  readonly requestId: string;
+  readonly request: Request;
+  readonly response: Response;
+  constructor(type: EventType, data: DataType);
+}
+declare class UnhandledExceptionEvent<DataType extends {
+  error: Error;
+  requestId: string;
+  request: Request;
+} = {
+  error: Error;
+  requestId: string;
+  request: Request;
+}, ReturnType = void, EventType extends string = string> extends TypedEvent<DataType, ReturnType, EventType> {
+  readonly error: Error;
+  readonly requestId: string;
+  readonly request: Request;
+  constructor(type: EventType, data: DataType);
+}
+type HttpNetworkFrameEventMap = {
+  'request:start': RequestEvent;
+  'request:match': RequestEvent;
+  'request:unhandled': RequestEvent;
+  'request:end': RequestEvent;
+  'response:mocked': ResponseEvent;
+  'response:bypass': ResponseEvent;
+  unhandledException: UnhandledExceptionEvent;
+};
+declare abstract class HttpNetworkFrame extends NetworkFrame<'http', {
+  id: string;
+  request: Request;
+}, HttpNetworkFrameEventMap> {
+  constructor(options: HttpNetworkFrameOptions);
+  getHandlers(controller: HandlersController): Array<AnyHandler>;
+  abstract respondWith(response?: Response): void;
+  getUnhandledMessage(): Promise<string>;
+  resolve(handlers: Array<RequestHandler>, onUnhandledFrame: UnhandledFrameHandle, resolutionContext?: NetworkFrameResolutionContext): Promise<boolean | null>;
+}
+//#endregion
+//#region src/core/experimental/sources/network-source.d.ts
+declare class NetworkFrameEvent<DataType = void, ReturnType = void, EventType extends string = string> extends TypedEvent<DataType, ReturnType, EventType> {
+  frame: AnyNetworkFrame;
+  constructor(type: string, frame: AnyNetworkFrame);
+}
+type NetworkSourceEventMap<Frame extends AnyNetworkFrame> = {
+  frame: NetworkFrameEvent<Frame>;
+};
+type ExtractSourceEvents<Source> = Source extends NetworkSource<infer Frame> ? ExtractFrameEvents<Frame> : never;
+declare abstract class NetworkSource<Frame extends AnyNetworkFrame = AnyNetworkFrame> {
+  protected emitter: Emitter<NetworkSourceEventMap<Frame>>;
+  constructor();
+  abstract enable(): unknown | Promise<unknown>;
+  queue(frame: Frame): Promise<void>;
+  on<Type extends keyof NetworkSourceEventMap<Frame>>(type: Type, listener: Emitter.Listener<typeof this.emitter, Type>, options?: TypedListenerOptions): void;
+  disable(): void | Promise<void>;
+}
+//#endregion
+//#region src/core/experimental/define-network.d.ts
+type MergeEventMaps<Sources extends Array<NetworkSource<any>>> = UnionToIntersection<ExtractSourceEvents<Sources[number]>> extends (infer R) ? R extends Record<string, any> ? R : DefaultEventMap : DefaultEventMap;
+type MaybePromise<T> = Extract<T, Promise<unknown>> extends never ? void : Promise<void>;
+interface DefineNetworkOptions<Sources extends Array<NetworkSource<any>>> {
+  /**
+   * List of the network sources.
+   * Every network source emits frames, and every frame describes how
+   * to handle the various network scenarios, like mocking a response,
+   * erroring the request, or performing it as-is.
+   */
+  sources: Sources;
+  /**
+   * List of handlers to describe the network.
+   */
+  handlers?: Array<AnyHandler> | HandlersController;
+  context?: NetworkFrameResolutionContext;
+  onUnhandledFrame?: UnhandledFrameHandle;
+}
+interface NetworkApi<Sources extends Array<NetworkSource<any>>> extends NetworkHandlersApi {
+  readyState: NetworkReadyState;
+  /**
+   * Enable the network interception and handling.
+   */
+  enable: () => MaybePromise<ReturnType<Sources[number]['enable']>>;
+  /**
+   * Disable the network interception and handling.
+   */
+  disable: () => MaybePromise<ReturnType<Sources[number]['disable']>>;
+  /**
+   * Configure the network instance with additional options.
+   * The options provided in the `.configure()` call will override the same
+   * options in the `defineNetwork()` call.
+   */
+  configure: (options: Partial<DefineNetworkOptions<Sources>>) => void;
+  events: Emitter<MergeEventMaps<Sources>>;
+}
+interface NetworkHandlersApi {
+  use: (...handlers: Array<AnyHandler>) => void;
+  resetHandlers: (...handlers: Array<AnyHandler>) => void;
+  restoreHandlers: () => void;
+  listHandlers: () => ReadonlyArray<AnyHandler>;
+}
+declare enum NetworkReadyState {
+  DISABLED = 0,
+  ENABLED = 1
+}
+/**
+ * Define a network instance with the given configuration.
+ * @example
+ * import { InterceptorSource } from 'msw/experimental'
+ * import { handlers } from './handlers'
+ *
+ * const network = defineNetwork({
+ *   sources: [new InterceptorSource({ interceptors })],
+ *   handlers,
+ * })
+ * await network.enable()
+ */
+declare function defineNetwork<Sources extends Array<NetworkSource<any>>>(options: DefineNetworkOptions<Sources>): NetworkApi<Sources>;
+//#endregion
+//#region src/core/experimental/sources/interceptor-source.d.ts
+interface InterceptorSourceOptions {
+  interceptors: Array<Interceptor<HttpRequestEventMap | WebSocketEventMap>>;
+}
+/**
+ * Create a network source from the given list of interceptors.
+ */
+declare class InterceptorSource extends NetworkSource {
+  #private;
+  constructor(options: InterceptorSourceOptions);
+  enable(): void;
+  disable(): void;
+}
+//#endregion
+export { defineNetwork as a, HttpNetworkFrameEventMap as c, NetworkReadyState as i, DefineNetworkOptions as n, NetworkSource as o, NetworkApi as r, HttpNetworkFrame as s, InterceptorSource as t };
+//# sourceMappingURL=interceptor-source.d.ts.map