msw 0.40.2 → 0.41.0

package/lib/types/graphql.d.ts

@@ -1,74 +0,0 @@
-import { DocumentNode } from 'graphql';
-import { ResponseResolver } from './handlers/RequestHandler';
-import { GraphQLHandler, GraphQLContext, GraphQLRequest, GraphQLVariables, GraphQLHandlerNameSelector } from './handlers/GraphQLHandler';
-import { Path } from './utils/matching/matchRequestUrl';
-export interface TypedDocumentNode<Result = {
-    [key: string]: any;
-}, Variables = {
-    [key: string]: any;
-}> extends DocumentNode {
-    __apiType?: (variables: Variables) => Result;
-    __resultType?: Result;
-    __variablesType?: Variables;
-}
-declare const standardGraphQLHandlers: {
-    /**
-     * 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: <Query extends Record<string, any>, Variables extends GraphQLVariables = GraphQLVariables>(resolver: ResponseResolver<GraphQLRequest<Variables>, GraphQLContext<Query>, any>) => GraphQLHandler<GraphQLRequest<Variables>>;
-    /**
-     * 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: <Query_1 extends Record<string, any>, Variables_1 extends GraphQLVariables = GraphQLVariables>(operationName: GraphQLHandlerNameSelector | TypedDocumentNode<Query_1, Variables_1>, resolver: ResponseResolver<GraphQLRequest<Variables_1>, GraphQLContext<Query_1>, any>) => GraphQLHandler<GraphQLRequest<Variables_1>>;
-    /**
-     * 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: <Query_1 extends Record<string, any>, Variables_1 extends GraphQLVariables = GraphQLVariables>(operationName: GraphQLHandlerNameSelector | TypedDocumentNode<Query_1, Variables_1>, resolver: ResponseResolver<GraphQLRequest<Variables_1>, GraphQLContext<Query_1>, any>) => GraphQLHandler<GraphQLRequest<Variables_1>>;
-};
-declare function createGraphQLLink(url: Path): typeof standardGraphQLHandlers;
-export declare const graphql: {
-    link: typeof createGraphQLLink;
-    /**
-     * 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: <Query extends Record<string, any>, Variables extends GraphQLVariables = GraphQLVariables>(resolver: ResponseResolver<GraphQLRequest<Variables>, GraphQLContext<Query>, any>) => GraphQLHandler<GraphQLRequest<Variables>>;
-    /**
-     * 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: <Query_1 extends Record<string, any>, Variables_1 extends GraphQLVariables = GraphQLVariables>(operationName: GraphQLHandlerNameSelector | TypedDocumentNode<Query_1, Variables_1>, resolver: ResponseResolver<GraphQLRequest<Variables_1>, GraphQLContext<Query_1>, any>) => GraphQLHandler<GraphQLRequest<Variables_1>>;
-    /**
-     * 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: <Query_1 extends Record<string, any>, Variables_1 extends GraphQLVariables = GraphQLVariables>(operationName: GraphQLHandlerNameSelector | TypedDocumentNode<Query_1, Variables_1>, resolver: ResponseResolver<GraphQLRequest<Variables_1>, GraphQLContext<Query_1>, any>) => GraphQLHandler<GraphQLRequest<Variables_1>>;
-};
-export {};

package/lib/types/handlers/GraphQLHandler.d.ts

@@ -1,39 +0,0 @@
-import { DocumentNode, OperationTypeNode } from 'graphql';
-import { SerializedResponse } from '../setupWorker/glossary';
-import { errors } from '../context/errors';
-import { GraphQLPayloadContext } from '../typeUtils';
-import { cookie } from '../context/cookie';
-import { DefaultContext, MockedRequest, RequestHandler, RequestHandlerDefaultInfo, ResponseResolver } from './RequestHandler';
-import { Path } from '../utils/matching/matchRequestUrl';
-import { ParsedGraphQLRequest, GraphQLMultipartRequestBody } from '../utils/internal/parseGraphQLRequest';
-export declare type ExpectedOperationTypeNode = OperationTypeNode | 'all';
-export declare type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
-export declare type GraphQLContext<QueryType extends Record<string, unknown>> = DefaultContext & {
-    data: GraphQLPayloadContext<QueryType>;
-    extensions: GraphQLPayloadContext<QueryType>;
-    errors: typeof errors;
-    cookie: typeof cookie;
-};
-export declare const graphqlContext: GraphQLContext<any>;
-export declare type GraphQLVariables = Record<string, any>;
-export interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
-    operationType: ExpectedOperationTypeNode;
-    operationName: GraphQLHandlerNameSelector;
-}
-export declare type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
-export interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
-    query: string;
-    variables?: Variables;
-}
-export interface GraphQLRequest<Variables extends GraphQLVariables> extends MockedRequest<GraphQLRequestBody<Variables>> {
-    variables: Variables;
-}
-export declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
-export declare class GraphQLHandler<Request extends GraphQLRequest<any> = GraphQLRequest<any>> extends RequestHandler<GraphQLHandlerInfo, Request, ParsedGraphQLRequest | null, GraphQLRequest<any>> {
-    private endpoint;
-    constructor(operationType: ExpectedOperationTypeNode, operationName: GraphQLHandlerNameSelector, endpoint: Path, resolver: ResponseResolver<any, any>);
-    parse(request: MockedRequest): ParsedGraphQLRequest<GraphQLVariables>;
-    protected getPublicRequest(request: Request, parsedResult: ParsedGraphQLRequest): GraphQLRequest<any>;
-    predicate(request: MockedRequest, parsedResult: ParsedGraphQLRequest): boolean;
-    log(request: Request, response: SerializedResponse, handler: this, parsedRequest: ParsedGraphQLRequest): void;
-}

package/lib/types/handlers/RequestHandler.d.ts

@@ -1,103 +0,0 @@
-import { Headers } from 'headers-polyfill';
-import { MaybePromise, MockedResponse, ResponseComposition } from '../response';
-import { status } from '../context/status';
-import { set } from '../context/set';
-import { delay } from '../context/delay';
-import { fetch } from '../context/fetch';
-import { ResponseResolutionContext } from '../utils/getResponse';
-import { SerializedResponse } from '../setupWorker/glossary';
-export declare type DefaultContext = {
-    status: typeof status;
-    set: typeof set;
-    delay: typeof delay;
-    fetch: typeof fetch;
-};
-export declare const defaultContext: DefaultContext;
-export declare type DefaultRequestMultipartBody = Record<string, string | File | (string | File)[]>;
-export declare type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;
-export interface MockedRequest<Body = DefaultBodyType> {
-    id: string;
-    url: URL;
-    method: Request['method'];
-    headers: Headers;
-    cookies: Record<string, string>;
-    mode: Request['mode'];
-    keepalive: Request['keepalive'];
-    cache: Request['cache'];
-    destination: Request['destination'];
-    integrity: Request['integrity'];
-    credentials: Request['credentials'];
-    redirect: Request['redirect'];
-    referrer: Request['referrer'];
-    referrerPolicy: Request['referrerPolicy'];
-    body: Body;
-    bodyUsed: Request['bodyUsed'];
-    passthrough: typeof passthrough;
-}
-export interface RequestHandlerDefaultInfo {
-    header: string;
-}
-export interface RequestHandlerInternalInfo {
-    callFrame?: string;
-}
-declare type ContextMap = Record<string, (...args: any[]) => any>;
-export declare type ResponseResolverReturnType<ReturnType> = ReturnType | undefined | void;
-export declare type MaybeAsyncResponseResolverReturnType<ReturnType> = MaybePromise<ResponseResolverReturnType<ReturnType>>;
-export declare type AsyncResponseResolverReturnType<ReturnType> = MaybeAsyncResponseResolverReturnType<ReturnType> | Generator<MaybeAsyncResponseResolverReturnType<ReturnType>, MaybeAsyncResponseResolverReturnType<ReturnType>, MaybeAsyncResponseResolverReturnType<ReturnType>>;
-export declare type ResponseResolver<RequestType = MockedRequest, ContextType = typeof defaultContext, BodyType = any> = (req: RequestType, res: ResponseComposition<BodyType>, context: ContextType) => AsyncResponseResolverReturnType<MockedResponse<BodyType>>;
-export interface RequestHandlerOptions<HandlerInfo> {
-    info: HandlerInfo;
-    resolver: ResponseResolver<any, any>;
-    ctx?: ContextMap;
-}
-export interface RequestHandlerExecutionResult<PublicRequestType> {
-    handler: RequestHandler;
-    parsedResult: any;
-    request: PublicRequestType;
-    response?: MockedResponse;
-}
-export declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, Request extends MockedRequest = MockedRequest, ParsedResult = any, PublicRequest extends MockedRequest = Request> {
-    info: HandlerInfo & RequestHandlerInternalInfo;
-    shouldSkip: boolean;
-    private ctx;
-    private resolverGenerator?;
-    private resolverGeneratorResult?;
-    protected resolver: ResponseResolver<any, any>;
-    constructor(options: RequestHandlerOptions<HandlerInfo>);
-    /**
-     * Determine if the captured request should be mocked.
-     */
-    abstract predicate(request: MockedRequest, parsedResult: ParsedResult, resolutionContext?: ResponseResolutionContext): boolean;
-    /**
-     * Print out the successfully handled request.
-     */
-    abstract log(request: Request, response: SerializedResponse<any>, handler: this, parsedResult: ParsedResult): void;
-    /**
-     * Parse the captured request to extract additional information from it.
-     * Parsed result is then exposed to other methods of this request handler.
-     */
-    parse(_request: MockedRequest, _resolutionContext?: ResponseResolutionContext): ParsedResult;
-    /**
-     * Test if this handler matches the given request.
-     */
-    test(request: MockedRequest, resolutionContext?: ResponseResolutionContext): boolean;
-    /**
-     * Derive the publicly exposed request (`req`) instance of the response resolver
-     * from the captured request and its parsed result.
-     */
-    protected getPublicRequest(request: MockedRequest, _parsedResult: ParsedResult): PublicRequest;
-    markAsSkipped(shouldSkip?: boolean): void;
-    /**
-     * Execute this request handler and produce a mocked response
-     * using the given resolver function.
-     */
-    run(request: MockedRequest, resolutionContext?: ResponseResolutionContext): Promise<RequestHandlerExecutionResult<PublicRequest> | null>;
-    private wrapResolver;
-    private createExecutionResult;
-}
-/**
- * Bypass this intercepted request.
- * This will make a call to the actual endpoint requested.
- */
-export declare function passthrough(): MockedResponse<null>;
-export {};

package/lib/types/handlers/RestHandler.d.ts

@@ -1,47 +0,0 @@
-import { body, cookie, json, text, xml } from '../context';
-import { SerializedResponse } from '../setupWorker/glossary';
-import { ResponseResolutionContext } from '../utils/getResponse';
-import { Match, Path, PathParams } from '../utils/matching/matchRequestUrl';
-import { DefaultBodyType, DefaultContext, MockedRequest, RequestHandler, RequestHandlerDefaultInfo, ResponseResolver } from './RequestHandler';
-declare type RestHandlerMethod = string | RegExp;
-export interface RestHandlerInfo extends RequestHandlerDefaultInfo {
-    method: RestHandlerMethod;
-    path: Path;
-}
-export declare enum RESTMethods {
-    HEAD = "HEAD",
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    OPTIONS = "OPTIONS",
-    DELETE = "DELETE"
-}
-export declare type RestContext = DefaultContext & {
-    cookie: typeof cookie;
-    text: typeof text;
-    body: typeof body;
-    json: typeof json;
-    xml: typeof xml;
-};
-export declare const restContext: RestContext;
-export declare type RequestQuery = {
-    [queryName: string]: string;
-};
-export interface RestRequest<BodyType extends DefaultBodyType = DefaultBodyType, ParamsType extends PathParams = PathParams> extends MockedRequest<BodyType> {
-    params: ParamsType;
-}
-export declare type ParsedRestRequest = Match;
-/**
- * Request handler for REST API requests.
- * Provides request matching based on method and URL.
- */
-export declare class RestHandler<RequestType extends MockedRequest<DefaultBodyType> = MockedRequest<DefaultBodyType>> extends RequestHandler<RestHandlerInfo, RequestType, ParsedRestRequest, RestRequest<RequestType extends MockedRequest<infer RequestBodyType> ? RequestBodyType : any, PathParams>> {
-    constructor(method: RestHandlerMethod, path: Path, resolver: ResponseResolver<any, any>);
-    private checkRedundantQueryParameters;
-    parse(request: RequestType, resolutionContext?: ResponseResolutionContext): Match;
-    protected getPublicRequest(request: RequestType, parsedResult: ParsedRestRequest): RestRequest<any, PathParams>;
-    predicate(request: RequestType, parsedResult: ParsedRestRequest): boolean;
-    log(request: RequestType, response: SerializedResponse): void;
-}
-export {};

package/lib/types/index.d.ts

@@ -1,26 +0,0 @@
-import * as context from './context';
-export { context };
-export { setupWorker } from './setupWorker/setupWorker';
-export { response, defaultResponse, createResponseComposition, } from './response';
-export { RequestHandler, defaultContext } from './handlers/RequestHandler';
-export { rest } from './rest';
-export { RestHandler, RESTMethods, restContext } from './handlers/RestHandler';
-export { graphql } from './graphql';
-export { GraphQLHandler, graphqlContext } from './handlers/GraphQLHandler';
-export { matchRequestUrl } from './utils/matching/matchRequestUrl';
-export { compose } from './utils/internal/compose';
-export * from './utils/handleRequest';
-export * from './utils/request/parseIsomorphicRequest';
-export { cleanUrl } from './utils/url/cleanUrl';
-/**
- * Type definitions.
- */
-export type { SetupWorkerApi, StartOptions } from './setupWorker/glossary';
-export type { SharedOptions } from './sharedOptions';
-export type { MockedRequest, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, DefaultBodyType, DefaultRequestMultipartBody, } from './handlers/RequestHandler';
-export type { MockedResponse, ResponseTransformer, ResponseComposition, ResponseCompositionOptions, ResponseFunction, } from './response';
-export type { RestContext, RequestQuery, RestRequest, ParsedRestRequest, } from './handlers/RestHandler';
-export type { GraphQLContext, GraphQLVariables, GraphQLRequest, GraphQLRequestBody, GraphQLJsonRequestBody, } from './handlers/GraphQLHandler';
-export type { Path, PathParams, Match } from './utils/matching/matchRequestUrl';
-export type { DelayMode } from './context/delay';
-export { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest';

package/lib/types/native/index.d.ts

@@ -1 +0,0 @@
-export declare const setupServer: (...requestHandlers: import("..").RequestHandler<import("../handlers/RequestHandler").RequestHandlerDefaultInfo, import("..").MockedRequest<import("..").DefaultBodyType>, any, import("..").MockedRequest<import("..").DefaultBodyType>>[]) => import("../node").SetupServerApi;

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

@@ -1,8 +0,0 @@
-import { Interceptor } from '@mswjs/interceptors';
-import { SetupServerApi } from './glossary';
-import { RequestHandler } from '../handlers/RequestHandler';
-/**
- * Creates a `setupServer` API using given request interceptors.
- * Useful to generate identical API using different patches to request issuing modules.
- */
-export declare function createSetupServer(...interceptors: Interceptor[]): (...requestHandlers: RequestHandler[]) => SetupServerApi;

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

@@ -1,38 +0,0 @@
-import { PartialDeep } from 'type-fest';
-import { IsomorphicResponse } from '@mswjs/interceptors';
-import { RequestHandler } from '../handlers/RequestHandler';
-import { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions } from '../sharedOptions';
-export declare type ServerLifecycleEventsMap = LifeCycleEventsMap<IsomorphicResponse>;
-export interface SetupServerApi {
-    /**
-     * Starts requests interception based on the previously provided request handlers.
-     * @see {@link https://mswjs.io/docs/api/setup-server/listen `server.listen()`}
-     */
-    listen(options?: PartialDeep<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: RequestHandler[]): 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: RequestHandler[]): void;
-    /**
-     * Lists all active request handlers.
-     * @see {@link https://mswjs.io/docs/api/setup-server/print-handlers `server.print-handlers()`}
-     */
-    printHandlers(): void;
-    events: LifeCycleEventEmitter<ServerLifecycleEventsMap>;
-}

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

@@ -1,2 +0,0 @@
-export { setupServer } from './setupServer';
-export type { SetupServerApi } from './glossary';

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

@@ -1,6 +0,0 @@
-/**
- * Sets up a requests interception in Node.js 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("..").RequestHandler<import("../handlers/RequestHandler").RequestHandlerDefaultInfo, import("..").MockedRequest<import("..").DefaultBodyType>, any, import("..").MockedRequest<import("..").DefaultBodyType>>[]) => import("./glossary").SetupServerApi;

package/lib/types/response.d.ts

@@ -1,35 +0,0 @@
-import { Headers } from 'headers-polyfill';
-export declare type MaybePromise<ValueType = any> = ValueType | Promise<ValueType>;
-/**
- * Internal representation of a mocked response instance.
- */
-export interface MockedResponse<BodyType = any> {
-    body: BodyType;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    once: boolean;
-    passthrough: boolean;
-    delay?: number;
-}
-export declare type ResponseTransformer<BodyType extends TransformerBodyType = any, TransformerBodyType = any> = (res: MockedResponse<TransformerBodyType>) => MaybePromise<MockedResponse<BodyType>>;
-export declare type ResponseFunction<BodyType = any> = (...transformers: ResponseTransformer<BodyType>[]) => MaybePromise<MockedResponse<BodyType>>;
-export declare type ResponseComposition<BodyType = any> = ResponseFunction<BodyType> & {
-    /**
-     * Respond using a given mocked response to the first captured request.
-     * Does not affect any subsequent captured requests.
-     */
-    once: ResponseFunction<BodyType>;
-    networkError: (message: string) => void;
-};
-export declare const defaultResponse: Omit<MockedResponse, 'headers'>;
-export declare type ResponseCompositionOptions<BodyType> = {
-    defaultTransformers?: ResponseTransformer<BodyType>[];
-    mockedResponseOverrides?: Partial<MockedResponse>;
-};
-export declare const defaultResponseTransformers: ResponseTransformer<any>[];
-export declare function createResponseComposition<BodyType>(responseOverrides?: Partial<MockedResponse<BodyType>>, defaultTransformers?: ResponseTransformer<BodyType>[]): ResponseFunction;
-export declare const response: ResponseFunction<any> & {
-    once: ResponseFunction<any>;
-    networkError(message: string): never;
-};

package/lib/types/rest.d.ts

@@ -1,13 +0,0 @@
-import { DefaultBodyType, ResponseResolver } from './handlers/RequestHandler';
-import { RestContext, RestHandler, RestRequest } from './handlers/RestHandler';
-import { Path, PathParams } from './utils/matching/matchRequestUrl';
-export declare const rest: {
-    all: <RequestBodyType extends DefaultBodyType = DefaultBodyType, Params extends PathParams<keyof Params> = PathParams<string>, ResponseBody extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    head: <RequestBodyType_1 extends DefaultBodyType = DefaultBodyType, Params_1 extends PathParams<keyof Params_1> = PathParams<string>, ResponseBody_1 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<never, Params_1>, RestContext, ResponseBody_1>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    get: <RequestBodyType_2 extends DefaultBodyType = DefaultBodyType, Params_2 extends PathParams<keyof Params_2> = PathParams<string>, ResponseBody_2 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<never, Params_2>, RestContext, ResponseBody_2>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    post: <RequestBodyType_3 extends DefaultBodyType = DefaultBodyType, Params_3 extends PathParams<keyof Params_3> = PathParams<string>, ResponseBody_3 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_3, Params_3>, RestContext, ResponseBody_3>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    put: <RequestBodyType_4 extends DefaultBodyType = DefaultBodyType, Params_4 extends PathParams<keyof Params_4> = PathParams<string>, ResponseBody_4 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_4, Params_4>, RestContext, ResponseBody_4>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    delete: <RequestBodyType_5 extends DefaultBodyType = DefaultBodyType, Params_5 extends PathParams<keyof Params_5> = PathParams<string>, ResponseBody_5 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_5, Params_5>, RestContext, ResponseBody_5>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    patch: <RequestBodyType_6 extends DefaultBodyType = DefaultBodyType, Params_6 extends PathParams<keyof Params_6> = PathParams<string>, ResponseBody_6 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_6, Params_6>, RestContext, ResponseBody_6>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-    options: <RequestBodyType_7 extends DefaultBodyType = DefaultBodyType, Params_7 extends PathParams<keyof Params_7> = PathParams<string>, ResponseBody_7 extends DefaultBodyType = DefaultBodyType>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_7, Params_7>, RestContext, ResponseBody_7>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultBodyType>>;
-};

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

@@ -1,161 +0,0 @@
-import { FlatHeadersObject } from 'headers-polyfill';
-import { StrictEventEmitter } from 'strict-event-emitter';
-import { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions } from '../sharedOptions';
-import { ServiceWorkerMessage } from '../utils/createBroadcastChannel';
-import { RequestHandler } from '../handlers/RequestHandler';
-import { InterceptorApi } from '@mswjs/interceptors';
-import { Path } from '../utils/matching/matchRequestUrl';
-import { RequiredDeep } from '../typeUtils';
-export declare type ResolvedPath = Path | URL;
-declare type RequestWithoutMethods = Omit<Request, 'text' | 'body' | 'json' | 'blob' | 'arrayBuffer' | 'formData' | 'clone' | 'signal' | 'isHistoryNavigation' | 'isReloadNavigation'>;
-/**
- * Request representation received from the worker message event.
- */
-export interface ServiceWorkerIncomingRequest extends RequestWithoutMethods {
-    /**
-     * Unique UUID of the request generated once the request is
-     * captured by the "fetch" event in the Service Worker.
-     */
-    id: string;
-    /**
-     * Text response body.
-     */
-    body: string | undefined;
-}
-export declare type ServiceWorkerIncomingResponse = Pick<Response, 'type' | 'ok' | 'status' | 'statusText' | 'body' | 'headers' | 'redirected'> & {
-    requestId: string;
-};
-/**
- * Map of the events that can be received from the Service Worker.
- */
-export interface ServiceWorkerIncomingEventsMap {
-    MOCKING_ENABLED: boolean;
-    INTEGRITY_CHECK_RESPONSE: string;
-    KEEPALIVE_RESPONSE: never;
-    REQUEST: ServiceWorkerIncomingRequest;
-    RESPONSE: ServiceWorkerIncomingResponse;
-}
-/**
- * Map of the events that can be sent to the Service Worker
- * from any execution context.
- */
-export declare type ServiceWorkerOutgoingEventTypes = 'MOCK_ACTIVATE' | 'MOCK_DEACTIVATE' | 'INTEGRITY_CHECK_REQUEST' | 'KEEPALIVE_REQUEST' | 'CLIENT_CLOSED';
-/**
- * Map of the events that can be sent to the Service Worker
- * only as a part of a single `fetch` event handler.
- */
-export declare type ServiceWorkerFetchEventTypes = 'MOCK_SUCCESS' | 'MOCK_NOT_FOUND' | 'NETWORK_ERROR' | 'INTERNAL_ERROR';
-export declare type WorkerLifecycleEventsMap = LifeCycleEventsMap<Response>;
-export interface SetupWorkerInternalContext {
-    isMockingEnabled: boolean;
-    startOptions?: RequiredDeep<StartOptions>;
-    worker: ServiceWorker | null;
-    registration: ServiceWorkerRegistration | null;
-    requestHandlers: RequestHandler[];
-    emitter: StrictEventEmitter<WorkerLifecycleEventsMap>;
-    keepAliveInterval?: number;
-    workerChannel: {
-        /**
-         * Adds a Service Worker event listener.
-         */
-        on<EventType extends keyof ServiceWorkerIncomingEventsMap>(eventType: EventType, callback: (event: MessageEvent, message: ServiceWorkerMessage<EventType, ServiceWorkerIncomingEventsMap[EventType]>) => void): void;
-        send<EventType extends ServiceWorkerOutgoingEventTypes>(eventType: EventType): void;
-    };
-    events: {
-        /**
-         * Adds an event listener on the given target.
-         * Returns a clean-up function that removes that listener.
-         */
-        addListener<EventType extends Event = Event>(target: EventTarget, eventType: string, listener: (event: EventType) => void): () => void;
-        /**
-         * Removes all currently attached listeners.
-         */
-        removeAllListeners(): void;
-        /**
-         * Awaits a given message type from the Service Worker.
-         */
-        once<EventType extends keyof ServiceWorkerIncomingEventsMap>(eventType: EventType): Promise<ServiceWorkerMessage<EventType, ServiceWorkerIncomingEventsMap[EventType]>>;
-    };
-    useFallbackMode: boolean;
-    fallbackInterceptor?: InterceptorApi;
-}
-export declare type ServiceWorkerInstanceTuple = [
-    ServiceWorker | null,
-    ServiceWorkerRegistration
-];
-export declare type FindWorker = (scriptUrl: string, mockServiceWorkerUrl: string) => boolean;
-export interface StartOptions extends SharedOptions {
-    /**
-     * Service Worker registration options.
-     */
-    serviceWorker?: {
-        /**
-         * Custom url to the worker script.
-         * @default "./mockServiceWorker.js"
-         */
-        url?: string;
-        options?: RegistrationOptions;
-    };
-    /**
-     * Disables the logging of captured requests
-     * into browser's console.
-     * @default false
-     */
-    quiet?: boolean;
-    /**
-     * Defers any network requests until the Service Worker
-     * instance is activated.
-     * @default true
-     */
-    waitUntilReady?: boolean;
-    /**
-     * A custom lookup function to find a Mock Service Worker in the list
-     * of all registered Service Workers on the page.
-     */
-    findWorker?: FindWorker;
-}
-export interface SerializedResponse<BodyType = any> {
-    status: number;
-    statusText: string;
-    headers: FlatHeadersObject;
-    body: BodyType;
-}
-export declare type StartReturnType = Promise<ServiceWorkerRegistration | undefined>;
-export declare type StartHandler = (options: RequiredDeep<StartOptions>, initialOptions: StartOptions) => StartReturnType;
-export declare type StopHandler = () => void;
-export interface SetupWorkerApi {
-    /**
-     * Registers and activates the mock Service Worker.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/start `worker.start()`}
-     */
-    start: (options?: StartOptions) => StartReturnType;
-    /**
-     * Stops requests interception for the current client.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/stop `worker.stop()`}
-     */
-    stop: StopHandler;
-    /**
-     * Prepends given request handlers to the list of existing handlers.
-     * @param {RequestHandler[]} handlers List of runtime request handlers.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/use `worker.use()`}
-     */
-    use: (...handlers: RequestHandler[]) => void;
-    /**
-     * Marks all request handlers that respond using `res.once()` as unused.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/restore-handlers `worker.restoreHandlers()`}
-     */
-    restoreHandlers: () => void;
-    /**
-     * Resets request handlers to the initial list given to the `setupWorker` call, or to the explicit next request handlers list, if given.
-     * @param {RequestHandler[]} nextHandlers List of the new initial request handlers.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/reset-handlers `worker.resetHandlers()`}
-     */
-    resetHandlers: (...nextHandlers: RequestHandler[]) => void;
-    /**
-     * Lists all active request handlers.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/print-handlers `worker.printHandlers()`}
-     */
-    printHandlers: () => void;
-    events: LifeCycleEventEmitter<WorkerLifecycleEventsMap>;
-}
-export {};

package/lib/types/setupWorker/setupWorker.d.ts

@@ -1,9 +0,0 @@
-import { SetupWorkerApi } from './glossary';
-import { RequestHandler } from '../handlers/RequestHandler';
-/**
- * Creates a new mock Service Worker registration
- * with the given request handlers.
- * @param {RequestHandler[]} requestHandlers List of request handlers
- * @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker`}
- */
-export declare function setupWorker(...requestHandlers: RequestHandler[]): SetupWorkerApi;

package/lib/types/setupWorker/start/createFallbackStart.d.ts

@@ -1,2 +0,0 @@
-import { SetupWorkerInternalContext, StartHandler } from '../glossary';
-export declare function createFallbackStart(context: SetupWorkerInternalContext): StartHandler;

package/lib/types/setupWorker/start/createStartHandler.d.ts

@@ -1,2 +0,0 @@
-import { SetupWorkerInternalContext, StartHandler } from '../glossary';
-export declare const createStartHandler: (context: SetupWorkerInternalContext) => StartHandler;

package/lib/types/setupWorker/start/utils/enableMocking.d.ts

@@ -1,5 +0,0 @@
-import { StartOptions, SetupWorkerInternalContext } from '../../glossary';
-/**
- * Signals the worker to enable the interception of requests.
- */
-export declare function enableMocking(context: SetupWorkerInternalContext, options: StartOptions): Promise<void>;

package/lib/types/setupWorker/start/utils/getWorkerByRegistration.d.ts

@@ -1,6 +0,0 @@
-import { FindWorker } from '../../glossary';
-/**
- * Attempts to resolve a Service Worker instance from a given registration,
- * regardless of its state (active, installing, waiting).
- */
-export declare const getWorkerByRegistration: (registration: ServiceWorkerRegistration, absoluteWorkerUrl: string, findWorker: FindWorker) => ServiceWorker | null;

package/lib/types/setupWorker/start/utils/getWorkerInstance.d.ts

@@ -1,6 +0,0 @@
-import { ServiceWorkerInstanceTuple, FindWorker } from '../../glossary';
-/**
- * Returns an active Service Worker instance.
- * When not found, registers a new Service Worker.
- */
-export declare const getWorkerInstance: (url: string, options: RegistrationOptions | undefined, findWorker: FindWorker) => Promise<ServiceWorkerInstanceTuple>;

package/lib/types/setupWorker/start/utils/prepareStartHandler.d.ts

@@ -1,9 +0,0 @@
-import { RequiredDeep } from '../../../typeUtils';
-import { SetupWorkerApi, SetupWorkerInternalContext, StartHandler, StartOptions } from '../../glossary';
-export declare const DEFAULT_START_OPTIONS: RequiredDeep<StartOptions>;
-/**
- * Returns resolved worker start options, merging the default options
- * with the given custom options.
- */
-export declare function resolveStartOptions(initialOptions?: StartOptions): RequiredDeep<StartOptions>;
-export declare function prepareStartHandler(handler: StartHandler, context: SetupWorkerInternalContext): SetupWorkerApi['start'];

package/lib/types/setupWorker/start/utils/printStartMessage.d.ts

@@ -1,10 +0,0 @@
-export interface PrintStartMessageArgs {
-    quiet?: boolean;
-    message?: string;
-    workerUrl?: string;
-    workerScope?: string;
-}
-/**
- * Prints a worker activation message in the browser's console.
- */
-export declare function printStartMessage(args?: PrintStartMessageArgs): void;

package/lib/types/setupWorker/start/utils/validateWorkerScope.d.ts

@@ -1,2 +0,0 @@
-import { StartOptions } from '../../glossary';
-export declare function validateWorkerScope(registration: ServiceWorkerRegistration, options?: StartOptions): void;