@zimic/fetch 1.4.1 → 1.4.3-canary.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { HttpSchema, HttpSchemaMethod, HttpSchemaPath, HttpMethodSchema, HttpHeadersSchema, HttpHeadersInit, HttpRequestHeadersSchema, HttpSearchParamsSchema, HttpSearchParamsInit, HttpRequestSearchParamsSchema, HttpBody, HttpRequestSchema, HttpSearchParams, HttpFormData, HttpRequest, HttpRequestBodySchema, AllowAnyStringInPathParams, HttpMethod, HttpStatusCode, HttpResponseSchemaStatusCode, HttpResponse, HttpResponseBodySchema, HttpResponseHeadersSchema, HttpHeadersSerialized, LiteralHttpSchemaPathFromNonLiteral } from '@zimic/http';
+import { HttpSchema, HttpSchemaMethod, HttpSchemaPath, HttpMethodSchema, HttpHeadersSchema, HttpHeadersInit, HttpRequestHeadersSchema, HttpSearchParamsSchema, HttpSearchParamsInit, HttpRequestSearchParamsSchema, HttpBody, HttpRequestSchema, HttpSearchParams, HttpFormData, HttpHeadersSerialized, HttpRequest, HttpRequestBodySchema, AllowAnyStringInPathParams, HttpMethod, LiteralHttpSchemaPathFromNonLiteral, HttpStatusCode, HttpResponseSchemaStatusCode, HttpResponseSchema, HttpResponseHeadersSchema, HttpResponse, HttpResponseBodySchema } from '@zimic/http';
 
 type JSON = {
     [key: string]: JSON;
@@ -88,7 +88,9 @@ type UnionToIntersection<Union> = (Union extends unknown ? (union: Union) => voi
 type IndexUnion<Union, Key> = Union extends Union ? (Key extends keyof Union ? Union[Key] : never) : never;
 type RequiredByKey<Type, Key extends keyof Type> = Omit<Type, Key> & Required<Pick<Type, Key>>;
 
-type FetchRequestInitWithHeaders<HeadersSchema extends HttpHeadersSchema | undefined> = [HeadersSchema] extends [never] ? {
+type FetchRequestInitWithHeaders<HeadersSchema extends HttpHeadersSchema | undefined> = [HeadersSchema] extends [
+    never
+] ? {
     headers?: undefined;
 } : undefined extends HeadersSchema ? {
     headers?: HttpHeadersInit<Default<HeadersSchema>>;
@@ -120,7 +122,6 @@ type FetchRequestInit<Schema extends HttpSchema, Method extends HttpSchemaMethod
     redirect?: Redirect;
     duplex?: 'half';
 } & (Path extends Path ? FetchRequestInitPerPath<Default<Schema[Path][Method]>> : never);
-/** @see {@link https://zimic.dev/docs/fetch/api/fetch `fetch` API reference} */
 declare namespace FetchRequestInit {
     type DefaultHeadersSchema<Schema extends HttpSchema> = {
         [Path in HttpSchemaPath.Literal<Schema>]: {
@@ -155,32 +156,103 @@ declare namespace FetchRequestInit {
     export type Loose = Partial<Defaults>;
     export {  };
 }
-type AllFetchResponseStatusCode<MethodSchema extends HttpMethodSchema> = HttpResponseSchemaStatusCode<Default<MethodSchema['response']>>;
-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>;
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-request#requesttoobject `request.toObject()`} */
+type FetchRequestObject = Pick<FetchRequest.Loose, 'url' | 'path' | 'method' | 'cache' | 'destination' | 'credentials' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'> & {
+    headers: HttpHeadersSerialized<HttpHeadersSchema>;
+    body?: HttpBody | null;
+};
+
+interface FetchRequestClass {
+    new <Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>>(fetch: Fetch<Schema>, input: FetchInput<Schema, Method, Path>, init?: FetchRequestInit<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>): FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
+    prototype: Request;
+    [Symbol.hasInstance]: (instance: unknown) => instance is FetchRequest<any, any, any>;
+}
 /** @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]>>>> {
+    raw: Request;
     path: AllowAnyStringInPathParams<Path>;
     method: Method;
+    clone: () => FetchRequest<Schema, Method, Path>;
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-request#requesttoobject `request.toObject()` API reference} */
+    toObject: ((options: {
+        includeBody: true;
+    }) => Promise<FetchRequestObject>) & ((options?: {
+        includeBody?: false;
+    }) => FetchRequestObject) & ((options?: {
+        includeBody?: boolean;
+    }) => PossiblePromise<FetchRequestObject>);
 }
 declare namespace FetchRequest {
     /** A loosely typed version of a {@link FetchRequest `FetchRequest`}. */
     interface Loose extends Request {
+        raw: Request;
         path: string;
         method: HttpMethod;
         clone: () => Loose;
+        /** @see {@link https://zimic.dev/docs/fetch/api/fetch-request#requesttoobject `request.toObject()` API reference} */
+        toObject: ((options: {
+            includeBody: true;
+        }) => Promise<FetchRequestObject>) & ((options?: {
+            includeBody?: false;
+        }) => FetchRequestObject);
     }
 }
-/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `error.toObject()`} */
-type FetchRequestObject = Pick<FetchRequest.Loose, 'url' | 'path' | 'method' | 'cache' | 'destination' | 'credentials' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'> & {
+declare const FetchRequest: FetchRequestClass;
+
+type AllFetchResponseStatusCode<MethodSchema extends HttpMethodSchema> = HttpResponseSchemaStatusCode<Default<MethodSchema['response']>>;
+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;
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response `FetchResponse` API reference} */
+type FetchResponseStatusCode<MethodSchema extends HttpMethodSchema, ErrorOnly extends boolean, Redirect extends RequestRedirect> = FilterFetchResponseStatusCodeByRedirect<FilterFetchResponseStatusCodeByError<AllFetchResponseStatusCode<MethodSchema>, ErrorOnly>, Redirect>;
+type FetchResponseInitWithHeaders<HeadersSchema extends HttpHeadersSchema | undefined> = FetchRequestInitWithHeaders<HeadersSchema>;
+type FetchResponseBodySchema<ResponseSchema extends HttpResponseSchema> = FetchRequestBodySchema<ResponseSchema>;
+type FetchResponseInitPerStatusCode<MethodSchema extends HttpMethodSchema, StatusCode extends AllFetchResponseStatusCode<MethodSchema>> = {
+    status: StatusCode;
+} & FetchResponseInitWithHeaders<HttpResponseHeadersSchema<MethodSchema, StatusCode>>;
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response `FetchResponse` API reference} */
+type FetchResponseInit<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath<Schema, Method>, 
+/** @deprecated The type parameter `ErrorOnly` will be removed in the next major version. */
+ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow', StatusCode extends FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect> = FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect>> = Omit<ResponseInit, 'headers' | 'status'> & (StatusCode extends StatusCode ? FetchResponseInitPerStatusCode<Default<Schema[Path][Method]>, StatusCode> : never);
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response `FetchResponse` API reference} */
+interface FetchResponseConstructor {
+    new <Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>, 
+    /** @deprecated The type parameter `ErrorOnly` will be removed in the next major version. */
+    ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow', StatusCode extends FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect> = FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect>>(fetchRequest: FetchRequest<Schema, Method, Path>, response?: Response): FetchResponse<Schema, Method, Path, ErrorOnly, Redirect, StatusCode>;
+    new <Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>, 
+    /** @deprecated The type parameter `ErrorOnly` will be removed in the next major version. */
+    ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow', StatusCode extends FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect> = FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect>>(fetchRequest: FetchRequest<Schema, Method, Path>, body?: FetchResponseBodySchema<Default<Default<Default<Schema[Path][Method]>['response']>[StatusCode]>>, init?: FetchResponseInit<Schema, Method, Path, ErrorOnly, Redirect, StatusCode>): FetchResponse<Schema, Method, Path, ErrorOnly, Redirect, StatusCode>;
+    [Symbol.hasInstance]: (instance: unknown) => boolean;
+}
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response#responsetoobject `response.toObject()`} */
+type FetchResponseObject = Pick<FetchResponse.Loose, 'url' | 'type' | 'status' | 'statusText' | 'ok' | 'redirected'> & {
     headers: HttpHeadersSerialized<HttpHeadersSchema>;
     body?: HttpBody | null;
 };
+
 /** @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> {
+    raw: Response;
     request: FetchRequest<Schema, Method, Path>;
     error: FetchResponseError<Schema, Method, Path>;
+    clone: () => FetchResponsePerStatusCode<Schema, Method, Path, StatusCode>;
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response#responsetoobject `response.toObject()` API reference} */
+    toObject: ((options: {
+        includeBody: true;
+    }) => Promise<FetchResponseObject>) & ((options?: {
+        includeBody?: false;
+    }) => FetchResponseObject) & ((options?: {
+        includeBody?: boolean;
+    }) => PossiblePromise<FetchResponseObject>);
+}
+interface FetchResponseClass {
+    new <Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>, 
+    /** @deprecated The type parameter `ErrorOnly` will be removed in the next major version. */
+    ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow', StatusCode extends FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect> = FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect>>(fetchRequest: FetchRequest<Schema, Method, Path>, response?: Response): FetchResponse<Schema, Method, Path, ErrorOnly, Redirect, StatusCode>;
+    new <Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.Literal<Schema, Method>, 
+    /** @deprecated The type parameter `ErrorOnly` will be removed in the next major version. */
+    ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow', StatusCode extends FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect> = FetchResponseStatusCode<Default<Schema[Path][Method]>, ErrorOnly, Redirect>>(fetchRequest: FetchRequest<Schema, Method, Path>, body?: FetchResponseBodySchema<Default<Default<Default<Schema[Path][Method]>['response']>[StatusCode]>>, init?: FetchResponseInit<Schema, Method, Path, ErrorOnly, Redirect, StatusCode>): FetchResponse<Schema, Method, Path, ErrorOnly, Redirect, StatusCode>;
+    prototype: Response;
+    [Symbol.hasInstance]: (instance: unknown) => instance is FetchResponse<any, any, any, any, any, any>;
 }
 /** @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>, 
@@ -189,75 +261,68 @@ ErrorOnly extends boolean = false, Redirect extends RequestRedirect = 'follow',
 declare namespace FetchResponse {
     /** A loosely typed version of a {@link FetchResponse}. */
     interface Loose extends Response {
+        raw: Response;
         request: FetchRequest.Loose;
         error: FetchResponseError<any, any, any>;
         clone: () => Loose;
+        /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response#responsetoobject `response.toObject()` API reference} */
+        toObject: ((options: {
+            includeBody: true;
+        }) => Promise<FetchResponseObject>) & ((options?: {
+            includeBody?: false;
+        }) => FetchResponseObject);
     }
 }
-/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `error.toObject()`} */
-type FetchResponseObject = Pick<FetchResponse.Loose, 'url' | 'type' | 'status' | 'statusText' | 'ok' | 'redirected'> & {
-    headers: HttpHeadersSerialized<HttpHeadersSchema>;
-    body?: HttpBody | null;
-};
-/** @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>>;
+declare const FetchResponse: FetchResponseClass;
 
-/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
 interface FetchResponseErrorObjectOptions {
-    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
     includeRequestBody?: boolean;
-    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
     includeResponseBody?: boolean;
 }
 declare namespace FetchResponseErrorObjectOptions {
-    /**
-     * Options for converting a {@link FetchResponseError `FetchResponseError`} into a plain object, including the body of
-     * the request and/or response.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
     type WithBody = FetchResponseErrorObjectOptions & ({
         includeRequestBody: true;
     } | {
         includeResponseBody: true;
     });
-    /**
-     * Options for converting a {@link FetchResponseError `FetchResponseError`} into a plain object, excluding the body of
-     * the request and/or response.
-     */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
     type WithoutBody = FetchResponseErrorObjectOptions & ({
         includeRequestBody?: false;
     } | {
         includeResponseBody?: false;
     });
 }
-/**
- * A plain object representation of a {@link FetchResponseError `FetchResponseError`}, compatible with JSON. It is useful
- * for serialization, debugging, and logging purposes.
- *
- * @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference}
- */
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
 interface FetchResponseErrorObject {
     name: string;
     message: string;
     request: FetchRequestObject;
     response: FetchResponseObject;
 }
+
 /** @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>;
     constructor(request: FetchRequest<Schema, Method, Path>, response: FetchResponse<Schema, Method, Path>);
-    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `fetchResponseError.toObject()` API reference} */
+    /** @see {@link https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject `response.error.toObject()` API reference} */
     toObject(options: FetchResponseErrorObjectOptions.WithBody): Promise<FetchResponseErrorObject>;
     toObject(options?: FetchResponseErrorObjectOptions.WithoutBody): FetchResponseErrorObject;
     toObject(options?: FetchResponseErrorObjectOptions): PossiblePromise<FetchResponseErrorObject>;
-    private requestToObject;
-    private responseToObject;
-    private convertHeadersToObject;
-    private withIncludedBodyIfAvailable;
 }
 
+/** @see {@link https://zimic.dev/docs/fetch/api/fetch#fetchrequest `fetch.Request` API reference} */
+interface FetchRequestConstructor<Schema extends HttpSchema> {
+    new <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>): FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
+    new <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Redirect extends RequestRedirect = 'follow'>(input: FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>, init?: Omit<FetchRequestInit<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Redirect>, 'baseURL' | 'searchParams'>): FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
+    new <Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Redirect extends RequestRedirect = 'follow'>(input: FetchInput<Schema, Method, Path>, init?: FetchRequestInit<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Redirect>): FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
+}
 /** @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>>;
+type FetchInput<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, Path extends HttpSchemaPath<Schema, Method>> = Path | URL | FetchRequest<Schema, Method, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>>;
 /** @see {@link https://zimic.dev/docs/fetch/api/fetch `fetch` API reference} */
 interface Fetch<Schema extends HttpSchema> extends Pick<FetchOptions<Schema>, 'onRequest' | 'onResponse'>, FetchDefaults<Schema> {
     <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>>;
@@ -327,4 +392,4 @@ type InferFetchSchema<FetchInstance> = FetchInstance extends Fetch<infer Schema>
 /** @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 };
+export { Fetch, type FetchDefaults, type FetchInput, type FetchOptions, FetchRequest, type FetchRequestConstructor, FetchRequestInit, type FetchRequestObject, FetchResponse, type FetchResponseConstructor, FetchResponseError, type FetchResponseErrorObject, FetchResponseErrorObjectOptions, type FetchResponseInit, type FetchResponseObject, type FetchResponsePerStatusCode, type FetchResponseStatusCode, type InferFetchSchema, type JSONStringified, createFetch };