@zimic/fetch 0.4.1-canary.0 → 0.4.1-canary.1

package/dist/index.d.ts

@@ -6,7 +6,7 @@ declare const value: unique symbol;
  *
  * This type is used to validate that the expected stringified body is passed to `fetch`.
  *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#using-a-json-body}
+ * @see {@link https://zimic.dev/docs/fetch/guides/bodies#json-request-body Using a JSON request body}
  */
 type JSONStringified<Value> = string & {
     [value]: Value;
@@ -46,13 +46,7 @@ type FetchRequestInitWithBody<BodySchema extends HttpBody> = [BodySchema] extend
     body: BodySchema;
 };
 type FetchRequestInitPerPath<MethodSchema extends HttpMethodSchema> = FetchRequestInitWithHeaders<HttpRequestHeadersSchema<MethodSchema>> & FetchRequestInitWithSearchParams<HttpRequestSearchParamsSchema<MethodSchema>> & FetchRequestInitWithBody<FetchRequestBodySchema<Default<MethodSchema['request']>>>;
-/**
- * The options to create a {@link FetchRequest} instance, compatible with
- * {@link https://developer.mozilla.org/docs/Web/API/RequestInit `RequestInit`}.
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch `fetch` API reference}
- * @see {@link https://developer.mozilla.org/docs/Web/API/RequestInit `RequestInit`}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch `fetch` API reference} */
 type FetchRequestInit<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath<Schema, Method>, Redirect extends RequestRedirect = 'follow'> = Omit<RequestInit, 'method' | 'headers' | 'body'> & {
     /** The HTTP method of the request. */
     method: Method;
@@ -78,55 +72,7 @@ type AllFetchResponseStatusCode<MethodSchema extends HttpMethodSchema> = HttpRes
 type FilterFetchResponseStatusCodeByError<StatusCode extends HttpStatusCode, ErrorOnly extends boolean> = ErrorOnly extends true ? Extract<StatusCode, HttpStatusCode.ClientError | HttpStatusCode.ServerError> : StatusCode;
 type FilterFetchResponseStatusCodeByRedirect<StatusCode extends HttpStatusCode, Redirect extends RequestRedirect> = Redirect extends 'error' ? FilterFetchResponseStatusCodeByRedirect<StatusCode, 'follow'> : Redirect extends 'follow' ? Exclude<StatusCode, Exclude<HttpStatusCode.Redirection, 304>> : StatusCode;
 type FetchResponseStatusCode<MethodSchema extends HttpMethodSchema, ErrorOnly extends boolean, Redirect extends RequestRedirect> = FilterFetchResponseStatusCodeByRedirect<FilterFetchResponseStatusCodeByError<AllFetchResponseStatusCode<MethodSchema>, ErrorOnly>, Redirect>;
-/**
- * A request instance typed with an HTTP schema, closely compatible with the
- * {@link https://developer.mozilla.org/docs/Web/API/Request native Request class}.
- *
- * On top of the properties available in native {@link https://developer.mozilla.org/docs/Web/API/Request `Request`}
- * instances, fetch requests have their URL automatically prefixed with the base URL of their fetch instance. Default
- * options are also applied, if present in the fetch instance.
- *
- * The path of the request is extracted from the URL, excluding the base URL, and is available in the `path` property.
- *
- * @example
- *   import { type HttpSchema } from '@zimic/http';
- *   import { createFetch } from '@zimic/fetch';
- *
- *   interface User {
- *     id: string;
- *     username: string;
- *   }
- *
- *   type Schema = HttpSchema<{
- *     '/users': {
- *       POST: {
- *         request: {
- *           headers: { 'content-type': 'application/json' };
- *           body: { username: string };
- *         };
- *         response: {
- *           201: { body: User };
- *         };
- *       };
- *     };
- *   }>;
- *
- *   const fetch = createFetch<Schema>({
- *     baseURL: 'http://localhost:3000',
- *   });
- *
- *   const request = new fetch.Request('/users', {
- *     method: 'POST',
- *     headers: { 'content-type': 'application/json' },
- *     body: JSON.stringify({ username: 'me' }),
- *   });
- *
- *   console.log(request); // FetchRequest<Schema, 'POST', '/users'>
- *   console.log(request.path); // '/users'
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchrequest `FetchRequest` API reference}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Request}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-request `FetchRequest` API reference} */
 interface FetchRequest<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>> extends HttpRequest<HttpRequestBodySchema<Default<Schema[Path][Method]>>, Default<HttpRequestHeadersSchema<Default<Schema[Path][Method]>>>> {
     /** The path of the request, excluding the base URL. */
     path: AllowAnyStringInPathParams<Path>;
@@ -159,12 +105,7 @@ type FetchRequestObject = Pick<FetchRequest.Loose, 'url' | 'path' | 'method' | '
      */
     body?: string | null;
 };
-/**
- * A {@link FetchResponse `FetchResponse`} instance with a specific status code.
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponse `FetchResponse` API reference}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Response}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response `FetchResponse` API reference} */
 interface FetchResponsePerStatusCode<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>, StatusCode extends HttpStatusCode = HttpStatusCode> extends HttpResponse<HttpResponseBodySchema<Default<Schema[Path][Method]>, StatusCode>, Default<HttpResponseHeadersSchema<Default<Schema[Path][Method]>, StatusCode>>, StatusCode> {
     /** The request that originated the response. */
     request: FetchRequest<Schema, Method, Path>;
@@ -176,57 +117,7 @@ interface FetchResponsePerStatusCode<Schema extends HttpSchema, Method extends H
      */
     error: StatusCode extends HttpStatusCode.ClientError | HttpStatusCode.ServerError ? FetchResponseError<Schema, Method, Path> : null;
 }
-/**
- * A response instance typed with an HTTP schema, closely compatible with the
- * {@link https://developer.mozilla.org/docs/Web/API/Response native Response class}.
- *
- * On top of the properties available in native Response instances, fetch responses have a reference to the request that
- * originated them, available in the `request` property.
- *
- * If the response has a failure status code (4XX or 5XX), an error is available in the `error` property.
- *
- * @example
- *   import { type HttpSchema } from '@zimic/http';
- *   import { createFetch } from '@zimic/fetch';
- *
- *   interface User {
- *     id: string;
- *     username: string;
- *   }
- *
- *   type Schema = HttpSchema<{
- *     '/users/:userId': {
- *       GET: {
- *         response: {
- *           200: { body: User };
- *           404: { body: { message: string } };
- *         };
- *       };
- *     };
- *   }>;
- *
- *   const fetch = createFetch<Schema>({
- *     baseURL: 'http://localhost:3000',
- *   });
- *
- *   const response = await fetch(`/users/${userId}`, {
- *     method: 'GET',
- *   });
- *
- *   console.log(response); // FetchResponse<Schema, 'GET', '/users'>
- *
- *   if (response.status === 404) {
- *     const errorBody = await response.json(); // { message: string }
- *     console.error(errorBody.message);
- *     return null;
- *   } else {
- *     const user = await response.json(); // User
- *     return user;
- *   }
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponse `FetchResponse` API reference}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Response}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response `FetchResponse` API reference} */
 type FetchResponse<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>, ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow', StatusCode extends FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect> = FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect>> = StatusCode extends StatusCode ? FetchResponsePerStatusCode<Schema, Method, Path, StatusCode> : never;
 declare namespace FetchResponse {
     /** A loosely typed version of a {@link FetchResponse}. */
@@ -259,56 +150,14 @@ type FetchResponseObject = Pick<FetchResponse.Loose, 'url' | 'type' | 'status' |
      */
     body?: string | null;
 };
-/**
- * A constructor for {@link FetchRequest} instances, typed with an HTTP schema and compatible with the
- * {@link https://developer.mozilla.org/docs/Web/API/Request Request class constructor}.
- *
- * @example
- *   import { type HttpSchema } from '@zimic/http';
- *   import { createFetch } from '@zimic/fetch';
- *
- *   type Schema = HttpSchema<{
- *     // ...
- *   }>;
- *
- *   const fetch = createFetch<Schema>({
- *     baseURL: 'http://localhost:3000',
- *   });
- *
- *   const request = new fetch.Request('POST', '/users', {
- *     body: JSON.stringify({ username: 'me' }),
- *   });
- *   console.log(request); // FetchRequest<Schema, 'POST', '/users'>
- *
- * @param input The resource to fetch, either a path, a URL, or a {@link FetchRequest request}. If a path is provided, it
- *   is automatically prefixed with the base URL of the fetch instance when the request is sent. If a URL or a request
- *   is provided, it is used as is.
- * @param init The request options. If a path or a URL is provided as the first argument, this argument is required and
- *   should contain at least the method of the request. If the first argument is a {@link FetchRequest request}, this
- *   argument is optional.
- * @returns A promise that resolves to the response to the request.
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponse `FetchResponse` API reference}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Request}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch#fetchrequest `fetch.Request` API reference} */
 type FetchRequestConstructor<Schema extends HttpSchema> = new <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>>(input: FetchInput<Schema, Method, Path>, init: FetchRequestInit<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>) => FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
 
-/**
- * Options for converting a {@link FetchResponseError `FetchResponseError`} into a plain object.
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponseerrortoobject `FetchResponseError#toObject` API reference}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
 interface FetchResponseErrorObjectOptions {
-    /**
-     * Whether to include the body of the request in the plain object.
-     *
-     * @default false
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
     includeRequestBody?: boolean;
-    /**
-     * Whether to include the body of the response in the plain object.
-     *
-     * @default false
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
     includeResponseBody?: boolean;
 }
 declare namespace FetchResponseErrorObjectOptions {
@@ -335,7 +184,7 @@ declare namespace FetchResponseErrorObjectOptions {
  * A plain object representation of a {@link FetchResponseError `FetchResponseError`}, compatible with JSON. It is useful
  * for serialization, debugging, and logging purposes.
  *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponseerrortoobject `FetchResponseError#toObject` API reference}
+ * @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference}
  */
 interface FetchResponseErrorObject {
     name: string;
@@ -343,80 +192,12 @@ interface FetchResponseErrorObject {
     request: FetchRequestObject;
     response: FetchResponseObject;
 }
-/**
- * An error representing a response with a failure status code (4XX or 5XX).
- *
- * @example
- *   import { type HttpSchema } from '@zimic/http';
- *   import { createFetch } from '@zimic/fetch';
- *
- *   interface User {
- *     id: string;
- *     username: string;
- *   }
- *
- *   type Schema = HttpSchema<{
- *     '/users/:userId': {
- *       GET: {
- *         response: {
- *           200: { body: User };
- *           404: { body: { message: string } };
- *         };
- *       };
- *     };
- *   }>;
- *
- *   const fetch = createFetch<Schema>({
- *     baseURL: 'http://localhost:3000',
- *   });
- *
- *   const response = await fetch(`/users/${userId}`, {
- *     method: 'GET',
- *   });
- *
- *   if (!response.ok) {
- *     console.log(response.status); // 404
- *
- *     console.log(response.error); // FetchResponseError<Schema, 'GET', '/users'>
- *     console.log(response.error.request); // FetchRequest<Schema, 'GET', '/users'>
- *     console.log(response.error.response); // FetchResponse<Schema, 'GET', '/users'>
- *
- *     const plainError = response.error.toObject();
- *     console.log(JSON.stringify(plainError));
- *     // {"name":"FetchResponseError","message":"...","request":{...},"response":{...}}
- *   }
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponseerror `FetchResponseError` API reference}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error `FetchResponseError` API reference} */
 declare class FetchResponseError<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>> extends Error {
     request: FetchRequest<Schema, Method, Path>;
     response: FetchResponse<Schema, Method, Path, true, 'manual'>;
     constructor(request: FetchRequest<Schema, Method, Path>, response: FetchResponse<Schema, Method, Path, true, 'manual'>);
-    /**
-     * Converts this error into a plain object. This method is useful for serialization, debugging, and logging purposes.
-     *
-     * @example
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:3000',
-     *   });
-     *
-     *   const response = await fetch(`/users/${userId}`, {
-     *     method: 'GET',
-     *   });
-     *
-     *   if (!response.ok) {
-     *     const plainError = response.error.toObject();
-     *     console.log(JSON.stringify(plainError));
-     *     // {"name":"FetchResponseError","message":"...","request":{...},"response":{...}}
-     *   }
-     *
-     * @param options Options for converting this error into a plain object. By default, the body of the request and
-     *   response will not be included.
-     * @returns A plain object representing this error. If `options.includeRequestBody` or `options.includeResponseBody`
-     *   is `true`, the body of the request and response will be included, respectively, and the return is a `Promise`.
-     *   Otherwise, the return is the plain object itself without the bodies.
-     * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchresponseerrortoobject `FetchResponseError#toObject` API reference}
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
     toObject(options: FetchResponseErrorObjectOptions.WithBody): Promise<FetchResponseErrorObject>;
     toObject(options: FetchResponseErrorObjectOptions.WithoutBody): FetchResponseErrorObject;
     toObject(options?: FetchResponseErrorObjectOptions): Promise<FetchResponseErrorObject> | FetchResponseErrorObject;
@@ -425,544 +206,44 @@ declare class FetchResponseError<Schema extends HttpSchema, Method extends HttpS
 }
 type AnyFetchRequestError = FetchResponseError<any, any, any>;
 
-/**
- * The input to fetch a resource, either a path, a URL, or a {@link FetchRequest request}.
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch `fetch` API reference}
- */
+/** @see {@link  https://zimic.dev/docs/fetch/api/fetch `fetch` API reference} */
 type FetchInput<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>> = Path | URL | FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
-/**
- * A fetch instance typed with an HTTP schema, closely compatible with the
- * {@link https://developer.mozilla.org/docs/Web/API/Fetch_API native Fetch API}. All requests and responses are typed by
- * default with the schema, including methods, paths, status codes, parameters, and bodies.
- *
- * Requests sent by the fetch instance have their URL automatically prefixed with the base URL of the instance. Default
- * options are also applied to the requests, if present in the instance.
- *
- * @example
- *   import { type HttpSchema } from '@zimic/http';
- *   import { createFetch } from '@zimic/fetch';
- *
- *   interface User {
- *     id: string;
- *     username: string;
- *   }
- *
- *   type Schema = HttpSchema<{
- *     '/users': {
- *       GET: {
- *         request: {
- *           searchParams: { query?: string };
- *         };
- *         response: {
- *           200: { body: User[] };
- *           404: { body: { message: string } };
- *           500: { body: { message: string } };
- *         };
- *       };
- *     };
- *   }>;
- *
- *   const fetch = createFetch<Schema>({
- *     baseURL: 'http://localhost:3000',
- *     headers: { 'accept-language': 'en' },
- *   });
- *
- *   const response = await fetch('/users', {
- *     method: 'GET',
- *     searchParams: { query: 'u' },
- *   });
- *
- *   if (response.status === 404) {
- *     return null; // User not found
- *   }
- *
- *   if (!response.ok) {
- *     throw response.error;
- *   }
- *
- *   const users = await response.json();
- *   return users; // User[]
- *
- * @param input The resource to fetch, either a path, a URL, or a {@link FetchRequest request}. If a path is provided, it
- *   is automatically prefixed with the base URL of the fetch instance when the request is sent. If a URL or a request
- *   is provided, it is used as is.
- * @param init The request options. If a path or a URL is provided as the first argument, this argument is required and
- *   should contain at least the method of the request. If the first argument is a {@link FetchRequest request}, this
- *   argument is optional.
- * @returns A promise that resolves to the response to the request.
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch `fetch` API reference}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Fetch_API}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Request}
- * @see {@link https://developer.mozilla.org/docs/Web/API/RequestInit}
- * @see {@link https://developer.mozilla.org/docs/Web/API/Response}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch `fetch` API reference} */
 interface Fetch<Schema extends HttpSchema> extends Pick<FetchOptions<Schema>, 'onRequest' | 'onResponse'> {
     <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Redirect extends RequestRedirect = 'follow'>(input: Path | URL, init: FetchRequestInit<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Redirect>): Promise<FetchResponse<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, false, Redirect>>;
     <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Redirect extends RequestRedirect = 'follow'>(input: FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>, init?: FetchRequestInit<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Redirect>): Promise<FetchResponse<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, false, Redirect>>;
-    /**
-     * The default options for each request sent by the fetch instance. The available options are the same as the
-     * {@link https://developer.mozilla.org/docs/Web/API/RequestInit `RequestInit`} options, plus `baseURL`.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface Post {
-     *     id: string;
-     *     title: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/posts': {
-     *       POST: {
-     *         request: {
-     *           headers: { 'content-type': 'application/json' };
-     *           body: { title: string };
-     *         };
-     *         response: {
-     *           201: { body: Post };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:3000',
-     *     headers: { 'accept-language': 'en' },
-     *   });
-     *
-     *   // Set the authorization header for all requests
-     *   const { accessToken } = await authenticate();
-     *
-     *   fetch.defaults.headers.authorization = `Bearer ${accessToken}`;
-     *   console.log(fetch.defaults.headers);
-     *
-     *   const response = await fetch('/posts', {
-     *     method: 'POST',
-     *     headers: { 'content-type': 'application/json' },
-     *     body: JSON.stringify({ title: 'My post' }),
-     *   });
-     *
-     *   const post = await response.json(); // Post
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch#fetchdefaults `fetch.defaults`} */
     defaults: FetchDefaults;
-    /**
-     * A loosely-typed version of {@link Fetch `fetch`}. This can be useful to make requests with fewer type constraints,
-     * such as in {@link onRequest `onRequest`} and {@link onResponse `onResponse`} listeners.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/auth/login': {
-     *       POST: {
-     *         request: {
-     *           headers: { 'content-type': 'application/json' };
-     *           body: { username: string; password: string };
-     *         };
-     *         response: {
-     *           201: { body: { accessToken: string } };
-     *         };
-     *       };
-     *     };
-     *
-     *     '/auth/refresh': {
-     *       POST: {
-     *         response: {
-     *           201: { body: { accessToken: string } };
-     *         };
-     *       };
-     *     };
-     *
-     *     '/users': {
-     *       GET: {
-     *         request: {
-     *           headers: { authorization: string };
-     *         };
-     *         response: {
-     *           200: { body: User[] };
-     *           401: { body: { message: string } };
-     *           403: { body: { message: string } };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL,
-     *
-     *     async onResponse(response) {
-     *       if (response.status === 401) {
-     *         const body = await response.clone().json();
-     *
-     *         if (body.message === 'Access token expired') {
-     *           // Refresh the access token
-     *           const refreshResponse = await this('/auth/refresh', { method: 'POST' });
-     *           const { accessToken } = await refreshResponse.json();
-     *
-     *           // Clone the original request and update its headers
-     *           const updatedRequest = response.request.clone();
-     *           updatedRequest.headers.set('authorization', `Bearer ${accessToken}`);
-     *
-     *           // Retry the original request with the updated headers
-     *           return this.loose(updatedRequest);
-     *         }
-     *       }
-     *
-     *       return response;
-     *     },
-     *   });
-     *
-     *   // Authenticate to your service before requests
-     *   const loginRequest = await fetch('/auth/login', {
-     *     method: 'POST',
-     *     headers: { 'content-type': 'application/json' },
-     *     body: JSON.stringify({ username: 'me', password: 'password' }),
-     *   });
-     *   const { accessToken } = await loginRequest.json();
-     *
-     *   // Set the authorization header for all requests
-     *   fetch.defaults.headers.authorization = `Bearer ${accessToken}`;
-     *
-     *   const request = await fetch('/users', {
-     *     method: 'GET',
-     *     searchParams: { query: 'u' },
-     *   });
-     *
-     *   const users = await request.json(); // User[]
-     *
-     * @param input The resource to fetch, either a path, a URL, or a {@link FetchRequest request}. If a path is provided,
-     *   it is automatically prefixed with the base URL of the fetch instance when the request is sent. If a URL or a
-     *   request is provided, it is used as is.
-     * @param init The request options. If a path or a URL is provided as the first argument, this argument is required
-     *   and should contain at least the method of the request. If the first argument is a {@link FetchRequest request},
-     *   this argument is optional.
-     * @returns A promise that resolves to the response to the request.
-     * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchloose `fetch.loose` API reference}
-     * @see {@link https://developer.mozilla.org/docs/Web/API/Fetch_API}
-     * @see {@link https://developer.mozilla.org/docs/Web/API/Request}
-     * @see {@link https://developer.mozilla.org/docs/Web/API/RequestInit}
-     * @see {@link https://developer.mozilla.org/docs/Web/API/Response}
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch#fetchloose `fetch.loose`} */
     loose: Fetch.Loose;
-    /**
-     * A constructor for creating
-     * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchrequest-1 `FetchRequest`}, closely compatible with
-     * the native {@link https://developer.mozilla.org/docs/Web/API/Request Request} constructor.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/users': {
-     *       POST: {
-     *         request: {
-     *           headers: { 'content-type': 'application/json' };
-     *           body: { username: string };
-     *         };
-     *         response: {
-     *           201: { body: User };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:3000',
-     *   });
-     *
-     *   const request = new fetch.Request('/users', {
-     *     method: 'POST',
-     *     headers: { 'content-type': 'application/json' },
-     *     body: JSON.stringify({ username: 'me' }),
-     *   });
-     *
-     *   console.log(request); // FetchRequest<Schema, 'POST', '/users'>
-     *   console.log(request.path); // '/users'
-     *
-     * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchrequest-1 `FetchRequest`}
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch#fetchrequest `fetch.Request`} */
     Request: FetchRequestConstructor<Schema>;
-    /**
-     * A type guard that checks if a request is a {@link FetchRequest}, was created by the fetch instance, and has a
-     * specific method and path. This is useful to narrow down the type of a request before using it.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/users': {
-     *       POST: {
-     *         request: {
-     *           headers: { 'content-type': 'application/json' };
-     *           body: { username: string };
-     *         };
-     *         response: {
-     *           201: { body: User };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:3000',
-     *   });
-     *
-     *   const request = new fetch.Request('/users', {
-     *     method: 'POST',
-     *     headers: { 'content-type': 'application/json' },
-     *     body: JSON.stringify({ username: 'me' }),
-     *   });
-     *
-     *   if (fetch.isRequest(request, 'POST', '/users')) {
-     *     // request is a FetchRequest<Schema, 'POST', '/users'>
-     *
-     *     const contentType = request.headers.get('content-type'); // 'application/json'
-     *     const body = await request.json(); // { username: string }
-     *   }
-     *
-     * @param request The request to check.
-     * @param method The method to check.
-     * @param path The path to check.
-     * @returns `true` if the request was created by the fetch instance and has the specified method and path; `false`
-     *   otherwise.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch#isrequest `fetch.isRequest`} */
     isRequest: <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>>(request: unknown, method: Method, path: Path) => request is FetchRequest<Schema, Method, Path>;
-    /**
-     * A type guard that checks if a response is a {@link FetchResponse}, was received by the fetch instance, and has a
-     * specific method and path. This is useful to narrow down the type of a response before using it.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/users': {
-     *       GET: {
-     *         request: {
-     *           searchParams: { query?: string };
-     *         };
-     *         response: {
-     *           200: { body: User[] };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:3000',
-     *   });
-     *
-     *   const response = await fetch('/users', {
-     *     method: 'GET',
-     *     searchParams: { query: 'u' },
-     *   });
-     *
-     *   if (fetch.isResponse(response, 'GET', '/users')) {
-     *     // response is a FetchResponse<Schema, 'GET', '/users'>
-     *
-     *     const users = await response.json(); // User[]
-     *   }
-     *
-     * @param response The response to check.
-     * @param method The method to check.
-     * @param path The path to check.
-     * @returns `true` if the response was received by the fetch instance and has the specified method and path; `false`
-     *   otherwise.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch#isresponseerror `fetch.isResponse`} */
     isResponse: <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>>(response: unknown, method: Method, path: Path) => response is FetchResponse<Schema, Method, Path>;
-    /**
-     * A type guard that checks if an error is a {@link FetchResponseError} related to a {@link FetchResponse response}
-     * received by the fetch instance with a specific method and path. This is useful to narrow down the type of an error
-     * before handling it.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/users': {
-     *       GET: {
-     *         request: {
-     *           searchParams: { query?: string };
-     *         };
-     *         response: {
-     *           200: { body: User[] };
-     *           400: { body: { message: string } };
-     *           500: { body: { message: string } };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:3000',
-     *   });
-     *
-     *   try {
-     *     const response = await fetch('/users', {
-     *       method: 'GET',
-     *       searchParams: { query: 'u' },
-     *     });
-     *
-     *     if (!response.ok) {
-     *       throw response.error; // FetchResponseError<Schema, 'GET', '/users'>
-     *     }
-     *   } catch (error) {
-     *     if (fetch.isResponseError(error, 'GET', '/users')) {
-     *       // error is a FetchResponseError<Schema, 'GET', '/users'>
-     *
-     *       const status = error.response.status; // 400 | 500
-     *       const { message } = await error.response.json(); // { message: string }
-     *
-     *       console.error('Could not fetch users:', { status, message });
-     *     }
-     *   }
-     *
-     * @param error The error to check.
-     * @param method The method to check.
-     * @param path The path to check.
-     * @returns `true` if the error is a response error received by the fetch instance and has the specified method and
-     *   path; `false` otherwise.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch#isresponseerror `fetch.isResponseError`} */
     isResponseError: <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>>(error: unknown, method: Method, path: Path) => error is FetchResponseError<Schema, Method, Path>;
 }
 declare namespace Fetch {
     /** A loosely-typed version of {@link Fetch `fetch`}. This can be useful to make requests with fewer type constraints, */
     type Loose = (input: string | URL | FetchRequest.Loose, init?: FetchRequestInit.Loose) => Promise<FetchResponse.Loose>;
 }
-/**
- * The options to create a {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch fetch instance}.
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#createfetch `createFetch(options)` API reference}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/create-fetch `createFetch` API reference} */
 interface FetchOptions<Schema extends HttpSchema> extends Omit<FetchRequestInit.Defaults, 'method'> {
-    /**
-     * A listener function that is called for each request. It can modify the requests before they are sent.
-     *
-     * @example
-     *   import { createFetch } from '@zimic/fetch';
-     *   import { type HttpSchema } from '@zimic/http';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/users': {
-     *       GET: {
-     *         request: {
-     *           searchParams: { page?: number; limit?: number };
-     *         };
-     *         response: {
-     *           200: { body: User[] };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:80',
-     *
-     *     onRequest(request) {
-     *       if (this.isRequest(request, 'GET', '/users')) {
-     *         const url = new URL(request.url);
-     *         url.searchParams.append('limit', '10');
-     *
-     *         const updatedRequest = new Request(url, request);
-     *         return updatedRequest;
-     *       }
-     *
-     *       return request;
-     *     },
-     *   });
-     *
-     * @param request The original request.
-     * @returns The request to be sent. It can be the original request or a modified version of it.
-     * @this {Fetch<Schema>} The fetch instance that is sending the request.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/create-fetch#onrequest `createFetch.onRequest`} API reference */
     onRequest?: (this: Fetch<Schema>, request: FetchRequest.Loose) => PossiblePromise<Request>;
-    /**
-     * A listener function that is called after each response is received. It can modify the responses before they are
-     * returned to the fetch caller.
-     *
-     * @example
-     *   import { type HttpSchema } from '@zimic/http';
-     *   import { createFetch } from '@zimic/fetch';
-     *
-     *   interface User {
-     *     id: string;
-     *     username: string;
-     *   }
-     *
-     *   type Schema = HttpSchema<{
-     *     '/users': {
-     *       GET: {
-     *         response: {
-     *           200: {
-     *             headers: { 'content-encoding'?: string };
-     *             body: User[];
-     *           };
-     *         };
-     *       };
-     *     };
-     *   }>;
-     *
-     *   const fetch = createFetch<Schema>({
-     *     baseURL: 'http://localhost:80',
-     *
-     *     onResponse(response) {
-     *       if (this.isResponse(response, 'GET', '/users')) {
-     *         console.log(response.headers.get('content-encoding'));
-     *       }
-     *       return response;
-     *     },
-     *   });
-     *
-     * @param response The original response.
-     * @returns The response to be returned.
-     * @this {Fetch<Schema>} The fetch instance that received the response.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/create-fetch#onresponse `createFetch.onResponse`} API reference */
     onResponse?: (this: Fetch<Schema>, response: FetchResponse.Loose) => PossiblePromise<Response>;
 }
 /**
  * The default options for each request sent by the fetch instance.
  *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetchdefaults `fetch.defaults` API reference}
+ * @see {@link https://zimic.dev/docs/fetch/api/fetch#fetchdefaults `fetch.defaults` API reference}
  */
 type FetchDefaults = RequiredByKey<FetchRequestInit.Defaults, 'headers' | 'searchParams'>;
 /**
- * Infers the schema of a {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch fetch instance}.
+ * Infers the schema of a {@link https://zimic.dev/docs/fetch/api/fetch fetch instance}.
  *
  * @example
  *   import { type HttpSchema } from '@zimic/http';
@@ -986,63 +267,11 @@ type FetchDefaults = RequiredByKey<FetchRequestInit.Defaults, 'headers' | 'searc
  *   //    };
  *   // };
  *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch `fetch` API reference}
+ * @see {@link https://zimic.dev/docs/fetch/api/fetch `fetch` API reference}
  */
 type InferFetchSchema<FetchInstance> = FetchInstance extends Fetch<infer Schema> ? Schema : never;
 
-/**
- * Creates a {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch fetch instance} typed with an HTTP
- * schema, closely compatible with the {@link https://developer.mozilla.org/docs/Web/API/Fetch_API native Fetch API}. All
- * requests and responses are typed by default with the schema, including methods, paths, status codes, parameters, and
- * bodies.
- *
- * Requests sent by the fetch instance have their URL automatically prefixed with the base URL of the instance.
- * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch.defaults Default options} are also applied to the
- * requests, if provided.
- *
- * @example
- *   import { type HttpSchema } from '@zimic/http';
- *   import { createFetch } from '@zimic/fetch';
- *
- *   interface User {
- *     id: string;
- *     username: string;
- *   }
- *
- *   type Schema = HttpSchema<{
- *     '/users': {
- *       POST: {
- *         request: {
- *           headers: { 'content-type': 'application/json' };
- *           body: { username: string };
- *         };
- *         response: {
- *           201: { body: User };
- *         };
- *       };
- *
- *       GET: {
- *         request: {
- *           searchParams: {
- *             query?: string;
- *             page?: number;
- *             limit?: number;
- *           };
- *         };
- *         response: {
- *           200: { body: User[] };
- *         };
- *       };
- *     };
- *   }>;
- *
- *   const fetch = createFetch<Schema>({
- *     baseURL: 'http://localhost:3000',
- *   });
- *
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#createfetch `createFetch(options)` API reference}
- * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐fetch#fetch `fetch` API reference}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/create-fetch `createFetch` API reference} */
 declare function createFetch<Schema extends HttpSchema>(options: FetchOptions<Schema>): Fetch<Schema>;
 
 export { Fetch, type FetchDefaults, type FetchInput, type FetchOptions, FetchRequest, type FetchRequestConstructor, FetchRequestInit, type FetchRequestObject, FetchResponse, FetchResponseError, type FetchResponseErrorObject, FetchResponseErrorObjectOptions, type FetchResponseObject, type FetchResponsePerStatusCode, type InferFetchSchema, type JSONStringified, createFetch };