@zimic/interceptor 0.15.0-canary.0 → 0.15.0-canary.1

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -19,7 +19,7 @@ import { BrowserHttpWorker, HttpResponseFactory, HttpWorker, NodeHttpWorker } fr
 class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   readonly type: 'local';
 
-  private _internalWorker?: HttpWorker;
+  private internalWorker?: HttpWorker;
 
   private defaultHttpHandler: MSWHttpHandler;
 
@@ -38,18 +38,18 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     });
   }
 
-  internalWorkerOrThrow() {
-    if (!this._internalWorker) {
+  get internalWorkerOrThrow() {
+    if (!this.internalWorker) {
       throw new NotStartedHttpInterceptorError();
     }
-    return this._internalWorker;
+    return this.internalWorker;
   }
 
-  internalWorkerOrCreate() {
-    if (!this._internalWorker) {
-      this._internalWorker = this.createInternalWorker();
+  get internalWorkerOrCreate() {
+    if (!this.internalWorker) {
+      this.internalWorker = this.createInternalWorker();
     }
-    return this._internalWorker;
+    return this.internalWorker;
   }
 
   private createInternalWorker() {
@@ -67,21 +67,21 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async start() {
     await super.sharedStart(async () => {
-      const internalWorker = this.internalWorkerOrCreate();
+      const internalWorker = this.internalWorkerOrCreate;
 
       const sharedOptions: MSWWorkerSharedOptions = {
         onUnhandledRequest: 'bypass',
       };
 
       if (this.isInternalBrowserWorker(internalWorker)) {
-        super.setPlatform('browser');
+        this.platform = 'browser';
         await this.startInBrowser(internalWorker, sharedOptions);
       } else {
-        super.setPlatform('node');
+        this.platform = 'node';
         this.startInNode(internalWorker, sharedOptions);
       }
 
-      super.setIsRunning(true);
+      this.isRunning = true;
     });
   }
 
@@ -106,7 +106,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async stop() {
     await super.sharedStop(() => {
-      const internalWorker = this.internalWorkerOrCreate();
+      const internalWorker = this.internalWorkerOrCreate;
 
       if (this.isInternalBrowserWorker(internalWorker)) {
         this.stopInBrowser(internalWorker);
@@ -115,8 +115,8 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
       }
       this.clearHandlers();
 
-      this._internalWorker = undefined;
-      super.setIsRunning(false);
+      this.internalWorker = undefined;
+      this.isRunning = false;
     });
   }
 
@@ -133,7 +133,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   hasInternalBrowserWorker() {
-    return this.isInternalBrowserWorker(this.internalWorkerOrThrow());
+    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
   }
 
   hasInternalNodeWorker() {
@@ -146,7 +146,6 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     rawURL: string | URL,
     createResponse: HttpResponseFactory,
   ) {
-    const internalWorker = this.internalWorkerOrThrow();
     const lowercaseMethod = method.toLowerCase<typeof method>();
 
     const url = new URL(rawURL);
@@ -180,7 +179,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
       return response;
     });
 
-    internalWorker.use(httpHandler);
+    this.internalWorkerOrThrow.use(httpHandler);
 
     this.httpHandlerGroups.push({ interceptor, httpHandler });
   }
@@ -199,25 +198,22 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   clearHandlers() {
-    const internalWorker = this.internalWorkerOrThrow();
-    internalWorker.resetHandlers();
+    this.internalWorkerOrThrow.resetHandlers();
     this.httpHandlerGroups = [];
   }
 
   clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
-    const internalWorker = this.internalWorkerOrThrow();
-
     const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
     removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
 
-    internalWorker.resetHandlers();
+    this.internalWorkerOrThrow.resetHandlers();
 
     for (const { httpHandler } of this.httpHandlerGroups) {
-      internalWorker.use(httpHandler);
+      this.internalWorkerOrThrow.use(httpHandler);
     }
   }
 
-  interceptorsWithHandlers() {
+  get interceptorsWithHandlers() {
     return this.httpHandlerGroups.map((group) => group.interceptor);
   }
 }

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -28,7 +28,8 @@ interface HttpHandler {
 class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
   readonly type: 'remote';
 
-  private _webSocketClient: WebSocketClient<InterceptorServerWebSocketSchema>;
+  webSocketClient: WebSocketClient<InterceptorServerWebSocketSchema>;
+
   private httpHandlers = new Map<HttpHandler['id'], HttpHandler>();
 
   constructor(options: RemoteHttpInterceptorWorkerOptions) {
@@ -36,7 +37,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     this.type = options.type;
 
     const webSocketServerURL = this.deriveWebSocketServerURL(options.serverURL);
-    this._webSocketClient = new WebSocketClient({
+    this.webSocketClient = new WebSocketClient({
       url: webSocketServerURL.toString(),
     });
   }
@@ -47,20 +48,15 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     return webSocketServerURL;
   }
 
-  webSocketClient() {
-    return this._webSocketClient;
-  }
-
   async start() {
     await super.sharedStart(async () => {
-      await this._webSocketClient.start();
+      await this.webSocketClient.start();
 
-      this._webSocketClient.onEvent('interceptors/responses/create', this.createResponse);
-      this._webSocketClient.onEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+      this.webSocketClient.onEvent('interceptors/responses/create', this.createResponse);
+      this.webSocketClient.onEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
 
-      const platform = this.readPlatform();
-      super.setPlatform(platform);
-      super.setIsRunning(true);
+      this.platform = this.readPlatform();
+      this.isRunning = true;
     });
   }
 
@@ -118,12 +114,12 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     await super.sharedStop(async () => {
       await this.clearHandlers();
 
-      this._webSocketClient.offEvent('interceptors/responses/create', this.createResponse);
-      this._webSocketClient.offEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+      this.webSocketClient.offEvent('interceptors/responses/create', this.createResponse);
+      this.webSocketClient.offEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
 
-      await this._webSocketClient.stop();
+      await this.webSocketClient.stop();
 
-      super.setIsRunning(false);
+      this.isRunning = false;
     });
   }
 
@@ -133,7 +129,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     rawURL: string | URL,
     createResponse: HttpResponseFactory,
   ) {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError();
     }
 
@@ -146,7 +142,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     const handler: HttpHandler = {
       id: crypto.randomUUID(),
       url: {
-        base: interceptor.baseURL(),
+        base: interceptor.baseURLAsString,
         full: url.toString(),
       },
       method,
@@ -159,7 +155,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
     this.httpHandlers.set(handler.id, handler);
 
-    await this._webSocketClient.request('interceptors/workers/use/commit', {
+    await this.webSocketClient.request('interceptors/workers/use/commit', {
       id: handler.id,
       url: handler.url,
       method,
@@ -167,19 +163,19 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   async clearHandlers() {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError();
     }
 
     this.httpHandlers.clear();
 
-    if (this._webSocketClient.isRunning()) {
-      await this._webSocketClient.request('interceptors/workers/use/reset', undefined);
+    if (this.webSocketClient.isRunning) {
+      await this.webSocketClient.request('interceptors/workers/use/reset', undefined);
     }
   }
 
   async clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError();
     }
 
@@ -189,18 +185,18 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
       }
     }
 
-    if (this._webSocketClient.isRunning()) {
+    if (this.webSocketClient.isRunning) {
       const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
         id: handler.id,
         url: handler.url,
         method: handler.method,
       }));
 
-      await this._webSocketClient.request('interceptors/workers/use/reset', groupsToRecommit);
+      await this.webSocketClient.request('interceptors/workers/use/reset', groupsToRecommit);
     }
   }
 
-  interceptorsWithHandlers() {
+  get interceptorsWithHandlers() {
     const interceptors = Array.from(this.httpHandlers.values(), (handler) => handler.interceptor);
     return interceptors;
   }

package/src/http/requestHandler/HttpRequestHandlerClient.ts

@@ -58,8 +58,7 @@ class HttpRequestHandlerClient<
 
   private numberOfMatchedRequests = 0;
   private unmatchedRequestGroups: UnmatchedHttpInterceptorRequestGroup[] = [];
-  private interceptedRequests: InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] =
-    [];
+  private _requests: InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] = [];
 
   private createResponseDeclaration?: HttpRequestHandlerResponseDeclarationFactory<
     Path,
@@ -69,19 +68,11 @@ class HttpRequestHandlerClient<
 
   constructor(
     private interceptor: HttpInterceptorClient<Schema>,
-    private _method: Method,
-    private _path: Path,
+    public method: Method,
+    public path: Path,
     private handler: InternalHttpRequestHandler<Schema, Method, Path, StatusCode>,
   ) {}
 
-  method() {
-    return this._method;
-  }
-
-  path() {
-    return this._path;
-  }
-
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
     this.restrictions.push(restriction);
     return this;
@@ -100,7 +91,7 @@ class HttpRequestHandlerClient<
 
     newThis.numberOfMatchedRequests = 0;
     newThis.unmatchedRequestGroups.length = 0;
-    newThis.interceptedRequests.length = 0;
+    newThis._requests.length = 0;
 
     this.interceptor.registerRequestHandler(this.handler);
 
@@ -141,7 +132,7 @@ class HttpRequestHandlerClient<
         declarationPointer: this.timesDeclarationPointer,
         unmatchedRequestGroups: this.unmatchedRequestGroups,
         hasRestrictions: this.restrictions.length > 0,
-        hasSavedRequests: this.interceptor.shouldSaveRequests(),
+        hasSavedRequests: this.interceptor.shouldSaveRequests,
       });
     }
   }
@@ -157,7 +148,7 @@ class HttpRequestHandlerClient<
 
     this.numberOfMatchedRequests = 0;
     this.unmatchedRequestGroups.length = 0;
-    this.interceptedRequests.length = 0;
+    this._requests.length = 0;
 
     this.createResponseDeclaration = undefined;
 
@@ -177,7 +168,7 @@ class HttpRequestHandlerClient<
       this.numberOfMatchedRequests++;
     } else {
       const shouldSaveUnmatchedGroup =
-        this.interceptor.shouldSaveRequests() &&
+        this.interceptor.shouldSaveRequests &&
         this.restrictions.length > 0 &&
         this.timesDeclarationPointer !== undefined;
 
@@ -388,7 +379,7 @@ class HttpRequestHandlerClient<
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
     const interceptedRequest = this.createInterceptedRequest(request, response);
-    this.interceptedRequests.push(interceptedRequest);
+    this._requests.push(interceptedRequest);
   }
 
   private createInterceptedRequest(
@@ -411,14 +402,12 @@ class HttpRequestHandlerClient<
     return interceptedRequest;
   }
 
-  requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
-    if (!this.interceptor.shouldSaveRequests()) {
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    if (!this.interceptor.shouldSaveRequests) {
       throw new DisabledRequestSavingError();
     }
 
-    const interceptedRequestsCopy = [...this.interceptedRequests];
-    Object.freeze(interceptedRequestsCopy);
-    return interceptedRequestsCopy;
+    return this._requests;
   }
 }
 

package/src/http/requestHandler/LocalHttpRequestHandler.ts

@@ -22,26 +22,22 @@ class LocalHttpRequestHandler<
 {
   readonly type = 'local';
 
-  private _client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 
   constructor(interceptor: HttpInterceptorClient<Schema>, method: Method, path: Path) {
-    this._client = new HttpRequestHandlerClient(interceptor, method, path, this);
+    this.client = new HttpRequestHandlerClient(interceptor, method, path, this);
   }
 
-  client() {
-    return this._client;
+  get method() {
+    return this.client.method;
   }
 
-  method() {
-    return this._client.method();
-  }
-
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
 
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this;
   }
 
@@ -50,45 +46,45 @@ class LocalHttpRequestHandler<
       | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
       | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): LocalHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
-    this._client.respond(declaration);
+    this.client.respond(declaration);
 
     const newThis = this as unknown as LocalHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
     return newThis;
   }
 
   times(minNumberOfRequests: number, maxNumberOfRequests?: number): this {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
 
   checkTimes() {
-    this._client.checkTimes();
+    this.client.checkTimes();
   }
 
   clear(): this {
-    this._client.clear();
+    this.client.clear();
     return this;
   }
 
-  requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
-    return this._client.requests();
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    return this.client.requests;
   }
 
   matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
 
   async applyResponseDeclaration(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
   ): Promise<HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, StatusCode>> {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
 
   saveInterceptedRequest(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
 }
 

package/src/http/requestHandler/RemoteHttpRequestHandler.ts

@@ -27,7 +27,7 @@ class RemoteHttpRequestHandler<
 {
   readonly type = 'remote';
 
-  private _client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 
   private syncPromises: Promise<unknown>[] = [];
 
@@ -35,7 +35,7 @@ class RemoteHttpRequestHandler<
   private synced: this;
 
   constructor(interceptor: HttpInterceptorClient<Schema, typeof RemoteHttpRequestHandler>, method: Method, path: Path) {
-    this._client = new HttpRequestHandlerClient(interceptor, method, path, this);
+    this.client = new HttpRequestHandlerClient(interceptor, method, path, this);
     this.unsynced = this;
     this.synced = this.createSyncedProxy();
   }
@@ -62,20 +62,16 @@ class RemoteHttpRequestHandler<
     return PENDING_PROPERTIES.has(property);
   }
 
-  client() {
-    return this._client;
+  get method() {
+    return this.client.method;
   }
 
-  method() {
-    return this._client.method();
-  }
-
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
 
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this.unsynced;
   }
 
@@ -85,19 +81,19 @@ class RemoteHttpRequestHandler<
       | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
     const newUnsyncedThis = this.unsynced as unknown as RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
-    newUnsyncedThis._client.respond(declaration);
+    newUnsyncedThis.client.respond(declaration);
     return newUnsyncedThis;
   }
 
   times(minNumberOfRequests: number, maxNumberOfRequests?: number): this {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
 
   async checkTimes() {
     return new Promise<void>((resolve, reject) => {
       try {
-        this._client.checkTimes();
+        this.client.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -106,42 +102,36 @@ class RemoteHttpRequestHandler<
   }
 
   clear(): this {
-    this._client.clear();
+    this.client.clear();
     return this.unsynced;
   }
 
-  requests(): Promise<readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[]> {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this._client.requests());
-      } catch (error) {
-        reject(error);
-      }
-    });
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    return this.client.requests;
   }
 
   matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
 
   async applyResponseDeclaration(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
   ): Promise<HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, StatusCode>> {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
 
   saveInterceptedRequest(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
 
   registerSyncPromise(promise: Promise<unknown>) {
     this.syncPromises.push(promise);
   }
 
-  isSynced(): boolean {
+  get isSynced() {
     return this.syncPromises.length === 0;
   }
 
@@ -162,7 +152,7 @@ class RemoteHttpRequestHandler<
       .then(() => {
         this.syncPromises = this.syncPromises.filter((promise) => !promisesToWait.has(promise));
 
-        return this.isSynced() ? this.synced : this.unsynced;
+        return this.isSynced ? this.synced : this.unsynced;
       })
       .then(onFulfilled, onRejected);
   }

package/src/http/requestHandler/types/public.ts

@@ -30,17 +30,19 @@ export interface HttpRequestHandler<
   Path extends HttpSchemaPath<Schema, Method>,
 > {
   /**
-   * @returns The method that matches this handler.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlermethod `handler.method()` API reference}
+   * The method that matches this handler.
+   *
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlermethod `handler.method` API reference}
    */
-  method: () => Method;
+  method: Method;
 
   /**
-   * @returns The path that matches this handler. The base URL of the interceptor is not included, but it is used when
-   *   matching requests.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerpath `handler.path()` API reference}
+   * The path that matches this handler. The base URL of the interceptor is not included, but it is used when matching
+   * requests.
+   *
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerpath `handler.path` API reference}
    */
-  path: () => Path;
+  path: Path;
 }
 
 export interface InternalHttpRequestHandler<
@@ -49,7 +51,7 @@ export interface InternalHttpRequestHandler<
   Path extends HttpSchemaPath<Schema, Method>,
   StatusCode extends HttpStatusCode = never,
 > extends HttpRequestHandler<Schema, Method, Path> {
-  client: () => HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 }
 
 /**
@@ -118,7 +120,7 @@ export interface LocalHttpRequestHandler<
    * intercepted request in the
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptormethodpath `interceptor.<method>(path)` API reference}.
    *
-   * **IMPORTANT**: To make sure that all expected requests were made, use
+   * **Important**: To make sure that all expected requests were made, use
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptorchecktimes `interceptor.checkTimes()`}
    * or {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlertimes `handler.times()`}.
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptorchecktimes `interceptor.checkTimes()`}
@@ -170,18 +172,17 @@ export interface LocalHttpRequestHandler<
   clear: () => this;
 
   /**
-   * Returns the intercepted requests that matched this handler, along with the responses returned to each of them. This
-   * is useful for testing that the correct requests were made by your application.
+   * The intercepted requests that matched this handler, along with the responses returned to each of them. This is
+   * useful for testing that the correct requests were made by your application.
    *
-   * **IMPORTANT**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
+   * **Important**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#saving-requests Saving intercepted requests}
    * for more information.
    *
-   * @returns The intercepted requests.
    * @throws {DisabledRequestSavingError} If the interceptor was not created with `saveRequests: true`.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests()` API reference}
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests` API reference}
    */
-  requests: () => readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[];
+  requests: readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[];
 }
 
 /**
@@ -249,7 +250,7 @@ export interface SyncedRemoteHttpRequestHandler<
    * intercepted request in the
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptormethodpath `interceptor.<method>(path)` API reference}.
    *
-   * **IMPORTANT**: To make sure that all expected requests were made, use
+   * **Important**: To make sure that all expected requests were made, use
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptorchecktimes `interceptor.checkTimes()`}
    * or
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerchecktimes `handler.checkTimes()`}.
@@ -306,20 +307,17 @@ export interface SyncedRemoteHttpRequestHandler<
   clear: () => PendingRemoteHttpRequestHandler<Schema, Method, Path, StatusCode>;
 
   /**
-   * Returns the intercepted requests that matched this handler, along with the responses returned to each of them. This
-   * is useful for testing that the correct requests were made by your application.
+   * The intercepted requests that matched this handler, along with the responses returned to each of them. This is
+   * useful for testing that the correct requests were made by your application.
    *
-   * **IMPORTANT**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
+   * **Important**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#saving-requests Saving intercepted requests}
    * for more information.
    *
-   * @returns The intercepted requests.
    * @throws {DisabledRequestSavingError} If the interceptor was not created with `saveRequests: true`.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests()` API reference}
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests` API reference}
    */
-  requests: () => Promise<
-    readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[]
-  >;
+  requests: readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[];
 }
 
 /**