@zap-studio/fetch 0.5.4 → 0.5.5

package/dist/internal.mjs

@@ -5,6 +5,35 @@ import { resolveRequestUrl } from "./url.mjs";
 import { standardValidate } from "@zap-studio/validation";
 //#region src/internal.ts
 /**
+* Normalizes request-level options into a final RequestInit payload and runtime flags.
+*
+* @param options - Request-level options.
+* @param defaults - Client-level defaults.
+* @returns Fully merged request init payload and effective runtime flags.
+*/
+const prepareRequestInit = (options, defaults) => {
+	const { headers, json, searchParams, throwOnFetchError = defaults.throwOnFetchError, throwOnValidationError = defaults.throwOnValidationError, ...rest } = options;
+	const init = { ...rest };
+	const mergedHeaders = mergeHeaders(defaults.headers, headers);
+	if (mergedHeaders !== void 0) init.headers = mergedHeaders;
+	if (json !== void 0) {
+		if (init.body !== void 0 && init.body !== null) throw new TypeError("Cannot provide both `body` and `json`.");
+		init.body = JSON.stringify(json);
+		if (init.headers === void 0) init.headers = new Headers({ "Content-Type": "application/json" });
+		else {
+			const requestHeaders = new Headers(init.headers);
+			if (!requestHeaders.has("Content-Type")) requestHeaders.set("Content-Type", "application/json");
+			init.headers = requestHeaders;
+		}
+	}
+	return {
+		init,
+		searchParams,
+		throwOnFetchError,
+		throwOnValidationError
+	};
+};
+/**
 * Internal fetch implementation used by both $fetch and createFetch.
 *
 * This function normalizes request input, resolves final URL + query params,
@@ -27,49 +56,19 @@ import { standardValidate } from "@zap-studio/validation";
 *   as an `AbortError` DOMException.
 * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
 *   response body.
-* @throws Any error thrown or rejected by the provided Standard Schema validator.
+* @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
 */
-async function fetchInternal(input, schema, options, defaults) {
+const fetchInternal = async (input, schema, options, defaults) => {
 	const request = normalizeRequest(input, options);
 	const { init, searchParams, throwOnFetchError, throwOnValidationError } = prepareRequestInit(request.options, defaults);
 	const url = resolveRequestUrl(request.url, defaults, searchParams);
 	const response = request.request ? await fetch(new Request(url, request.request), init) : await fetch(url, init);
 	if (throwOnFetchError && !response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response);
-	if (!schema) return response;
+	if (schema === void 0) return response;
 	const raw = await response.json();
-	if (throwOnValidationError) return standardValidate(schema, raw, { throwOnError: true });
-	return standardValidate(schema, raw, { throwOnError: false });
-}
-/**
-* Normalizes request-level options into a final RequestInit payload and runtime flags.
-*
-* @param options - Request-level options.
-* @param defaults - Client-level defaults.
-* @returns Fully merged request init payload and effective runtime flags.
-*/
-function prepareRequestInit(options, defaults) {
-	const { headers, json, searchParams, throwOnFetchError = defaults.throwOnFetchError, throwOnValidationError = defaults.throwOnValidationError, ...rest } = options;
-	const init = {
-		...rest,
-		headers: mergeHeaders(defaults.headers, headers)
-	};
-	if (json !== void 0) {
-		if (init.body != null) throw new TypeError("Cannot provide both `body` and `json`.");
-		init.body = JSON.stringify(json);
-		if (!init.headers) init.headers = new Headers({ "Content-Type": "application/json" });
-		else {
-			const headers = new Headers(init.headers);
-			if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
-			init.headers = headers;
-		}
-	}
-	return {
-		init,
-		searchParams,
-		throwOnFetchError,
-		throwOnValidationError
-	};
-}
+	if (throwOnValidationError) return await standardValidate(schema, raw, { throwOnError: true });
+	return await standardValidate(schema, raw, { throwOnError: false });
+};
 //#endregion
 export { fetchInternal };
 

package/dist/internal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"internal.mjs","names":[],"sources":["../src/internal.ts"],"sourcesContent":["/**\n * Internal request execution and option preparation utilities.\n *\n * @module @zap-studio/fetch/internal\n */\n\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\nimport { standardValidate } from \"@zap-studio/validation\";\n\nimport { FetchError } from \"./errors.js\";\nimport { mergeHeaders } from \"./headers.js\";\nimport { normalizeRequest } from \"./request.js\";\nimport type { ExtendedRequestInit, FetchDefaults, FetchInput } from \"./types.js\";\nimport { resolveRequestUrl } from \"./url.js\";\n\n/**\n * Internal fetch implementation used by both $fetch and createFetch.\n *\n * This function normalizes request input, resolves final URL + query params,\n * executes `fetch`, optionally throws `FetchError`, and optionally validates\n * JSON response payloads using Standard Schema.\n *\n * @param input - Request URL, path, or Request object.\n * @param schema - Optional Standard Schema for response validation.\n * @param options - Optional request options and package-specific flags.\n * @param defaults - Effective client defaults.\n * @returns Raw `Response` when no schema is provided; otherwise validated output.\n * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.\n * @throws {ValidationError} When a schema is provided, validation returns issues, and\n *   `throwOnValidationError` is `true`.\n * @throws {TypeError} When both `body` and `json` are provided, when JSON request\n *   serialization fails, when request construction fails, when headers/search params are\n *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`\n *   implementation rejects network-level failures as `TypeError`.\n * @throws {DOMException} When the runtime rejects an aborted request or response body read\n *   as an `AbortError` DOMException.\n * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the\n *   response body.\n * @throws Any error thrown or rejected by the provided Standard Schema validator.\n */\nexport async function fetchInternal(\n  input: FetchInput,\n  schema: StandardSchemaV1 | undefined,\n  options: ExtendedRequestInit | undefined,\n  defaults: FetchDefaults,\n): Promise<unknown> {\n  const request = normalizeRequest(input, options);\n  const { init, searchParams, throwOnFetchError, throwOnValidationError } = prepareRequestInit(\n    request.options,\n    defaults,\n  );\n  const url = resolveRequestUrl(request.url, defaults, searchParams);\n  const response = request.request\n    ? await fetch(new Request(url, request.request), init)\n    : await fetch(url, init);\n\n  if (throwOnFetchError && !response.ok) {\n    throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response);\n  }\n\n  if (!schema) {\n    return response;\n  }\n\n  const raw = await response.json();\n  if (throwOnValidationError) {\n    return standardValidate(schema, raw, { throwOnError: true });\n  }\n  return standardValidate(schema, raw, { throwOnError: false });\n}\n\n/**\n * Normalizes request-level options into a final RequestInit payload and runtime flags.\n *\n * @param options - Request-level options.\n * @param defaults - Client-level defaults.\n * @returns Fully merged request init payload and effective runtime flags.\n */\nfunction prepareRequestInit(\n  options: ExtendedRequestInit,\n  defaults: FetchDefaults,\n): {\n  init: RequestInit;\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined;\n  throwOnFetchError: boolean;\n  throwOnValidationError: boolean;\n} {\n  const {\n    headers,\n    json,\n    searchParams,\n    throwOnFetchError = defaults.throwOnFetchError,\n    throwOnValidationError = defaults.throwOnValidationError,\n    ...rest\n  } = options;\n\n  const init = {\n    ...rest,\n    headers: mergeHeaders(defaults.headers, headers),\n  } as RequestInit;\n\n  if (json !== undefined) {\n    if (init.body != null) {\n      throw new TypeError(\"Cannot provide both `body` and `json`.\");\n    }\n\n    init.body = JSON.stringify(json);\n    if (!init.headers) {\n      init.headers = new Headers({ \"Content-Type\": \"application/json\" });\n    } else {\n      const headers = new Headers(init.headers);\n      if (!headers.has(\"Content-Type\")) {\n        headers.set(\"Content-Type\", \"application/json\");\n      }\n      init.headers = headers;\n    }\n  }\n\n  return {\n    init,\n    searchParams,\n    throwOnFetchError,\n    throwOnValidationError,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,eAAsB,cACpB,OACA,QACA,SACA,UACkB;CAClB,MAAM,UAAU,iBAAiB,OAAO,QAAQ;CAChD,MAAM,EAAE,MAAM,cAAc,mBAAmB,2BAA2B,mBACxE,QAAQ,SACR,SACD;CACD,MAAM,MAAM,kBAAkB,QAAQ,KAAK,UAAU,aAAa;CAClE,MAAM,WAAW,QAAQ,UACrB,MAAM,MAAM,IAAI,QAAQ,KAAK,QAAQ,QAAQ,EAAE,KAAK,GACpD,MAAM,MAAM,KAAK,KAAK;AAE1B,KAAI,qBAAqB,CAAC,SAAS,GACjC,OAAM,IAAI,WAAW,QAAQ,SAAS,OAAO,IAAI,SAAS,cAAc,SAAS;AAGnF,KAAI,CAAC,OACH,QAAO;CAGT,MAAM,MAAM,MAAM,SAAS,MAAM;AACjC,KAAI,uBACF,QAAO,iBAAiB,QAAQ,KAAK,EAAE,cAAc,MAAM,CAAC;AAE9D,QAAO,iBAAiB,QAAQ,KAAK,EAAE,cAAc,OAAO,CAAC;;;;;;;;;AAU/D,SAAS,mBACP,SACA,UAMA;CACA,MAAM,EACJ,SACA,MACA,cACA,oBAAoB,SAAS,mBAC7B,yBAAyB,SAAS,wBAClC,GAAG,SACD;CAEJ,MAAM,OAAO;EACX,GAAG;EACH,SAAS,aAAa,SAAS,SAAS,QAAQ;EACjD;AAED,KAAI,SAAS,KAAA,GAAW;AACtB,MAAI,KAAK,QAAQ,KACf,OAAM,IAAI,UAAU,yCAAyC;AAG/D,OAAK,OAAO,KAAK,UAAU,KAAK;AAChC,MAAI,CAAC,KAAK,QACR,MAAK,UAAU,IAAI,QAAQ,EAAE,gBAAgB,oBAAoB,CAAC;OAC7D;GACL,MAAM,UAAU,IAAI,QAAQ,KAAK,QAAQ;AACzC,OAAI,CAAC,QAAQ,IAAI,eAAe,CAC9B,SAAQ,IAAI,gBAAgB,mBAAmB;AAEjD,QAAK,UAAU;;;AAInB,QAAO;EACL;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"internal.mjs","names":[],"sources":["../src/internal.ts"],"sourcesContent":["/**\n * Internal request execution and option preparation utilities.\n *\n * @module @zap-studio/fetch/internal\n */\n\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\nimport { standardValidate } from \"@zap-studio/validation\";\n\nimport { FetchError } from \"./errors.js\";\nimport { mergeHeaders } from \"./headers.js\";\nimport { normalizeRequest } from \"./request.js\";\nimport type {\n  ExtendedRequestInit,\n  FetchDefaults,\n  FetchInput,\n} from \"./types.js\";\nimport { resolveRequestUrl } from \"./url.js\";\n\n/**\n * Normalizes request-level options into a final RequestInit payload and runtime flags.\n *\n * @param options - Request-level options.\n * @param defaults - Client-level defaults.\n * @returns Fully merged request init payload and effective runtime flags.\n */\nconst prepareRequestInit = (\n  options: ExtendedRequestInit,\n  defaults: FetchDefaults\n): {\n  init: RequestInit;\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined;\n  throwOnFetchError: boolean;\n  throwOnValidationError: boolean;\n} => {\n  const {\n    headers,\n    json,\n    searchParams,\n    throwOnFetchError = defaults.throwOnFetchError,\n    throwOnValidationError = defaults.throwOnValidationError,\n    ...rest\n  } = options;\n\n  const init: RequestInit = { ...rest };\n  const mergedHeaders = mergeHeaders(defaults.headers, headers);\n  if (mergedHeaders !== undefined) {\n    init.headers = mergedHeaders;\n  }\n\n  if (json !== undefined) {\n    if (init.body !== undefined && init.body !== null) {\n      throw new TypeError(\"Cannot provide both `body` and `json`.\");\n    }\n\n    init.body = JSON.stringify(json);\n    if (init.headers === undefined) {\n      init.headers = new Headers({ \"Content-Type\": \"application/json\" });\n    } else {\n      const requestHeaders = new Headers(init.headers);\n      if (!requestHeaders.has(\"Content-Type\")) {\n        requestHeaders.set(\"Content-Type\", \"application/json\");\n      }\n      init.headers = requestHeaders;\n    }\n  }\n\n  return {\n    init,\n    searchParams,\n    throwOnFetchError,\n    throwOnValidationError,\n  };\n};\n\n/**\n * Internal fetch implementation used by both $fetch and createFetch.\n *\n * This function normalizes request input, resolves final URL + query params,\n * executes `fetch`, optionally throws `FetchError`, and optionally validates\n * JSON response payloads using Standard Schema.\n *\n * @param input - Request URL, path, or Request object.\n * @param schema - Optional Standard Schema for response validation.\n * @param options - Optional request options and package-specific flags.\n * @param defaults - Effective client defaults.\n * @returns Raw `Response` when no schema is provided; otherwise validated output.\n * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.\n * @throws {ValidationError} When a schema is provided, validation returns issues, and\n *   `throwOnValidationError` is `true`.\n * @throws {TypeError} When both `body` and `json` are provided, when JSON request\n *   serialization fails, when request construction fails, when headers/search params are\n *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`\n *   implementation rejects network-level failures as `TypeError`.\n * @throws {DOMException} When the runtime rejects an aborted request or response body read\n *   as an `AbortError` DOMException.\n * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the\n *   response body.\n * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.\n */\nexport const fetchInternal = async (\n  input: FetchInput,\n  schema: StandardSchemaV1 | undefined,\n  options: ExtendedRequestInit | undefined,\n  defaults: FetchDefaults\n): Promise<unknown> => {\n  const request = normalizeRequest(input, options);\n  const { init, searchParams, throwOnFetchError, throwOnValidationError } =\n    prepareRequestInit(request.options, defaults);\n  const url = resolveRequestUrl(request.url, defaults, searchParams);\n  const response = request.request\n    ? await fetch(new Request(url, request.request), init)\n    : await fetch(url, init);\n\n  if (throwOnFetchError && !response.ok) {\n    throw new FetchError(\n      `HTTP ${response.status}: ${response.statusText}`,\n      response\n    );\n  }\n\n  if (schema === undefined) {\n    return response;\n  }\n\n  const raw: unknown = await response.json();\n  if (throwOnValidationError) {\n    return await standardValidate(schema, raw, { throwOnError: true });\n  }\n  return await standardValidate(schema, raw, { throwOnError: false });\n};\n"],"mappings":";;;;;;;;;;;;;AA0BA,MAAM,sBACJ,SACA,aAMG;CACH,MAAM,EACJ,SACA,MACA,cACA,oBAAoB,SAAS,mBAC7B,yBAAyB,SAAS,wBAClC,GAAG,SACD;CAEJ,MAAM,OAAoB,EAAE,GAAG,KAAK;CACpC,MAAM,gBAAgB,aAAa,SAAS,SAAS,OAAO;CAC5D,IAAI,kBAAkB,KAAA,GACpB,KAAK,UAAU;CAGjB,IAAI,SAAS,KAAA,GAAW;EACtB,IAAI,KAAK,SAAS,KAAA,KAAa,KAAK,SAAS,MAC3C,MAAM,IAAI,UAAU,wCAAwC;EAG9D,KAAK,OAAO,KAAK,UAAU,IAAI;EAC/B,IAAI,KAAK,YAAY,KAAA,GACnB,KAAK,UAAU,IAAI,QAAQ,EAAE,gBAAgB,mBAAmB,CAAC;OAC5D;GACL,MAAM,iBAAiB,IAAI,QAAQ,KAAK,OAAO;GAC/C,IAAI,CAAC,eAAe,IAAI,cAAc,GACpC,eAAe,IAAI,gBAAgB,kBAAkB;GAEvD,KAAK,UAAU;EACjB;CACF;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,gBAAgB,OAC3B,OACA,QACA,SACA,aACqB;CACrB,MAAM,UAAU,iBAAiB,OAAO,OAAO;CAC/C,MAAM,EAAE,MAAM,cAAc,mBAAmB,2BAC7C,mBAAmB,QAAQ,SAAS,QAAQ;CAC9C,MAAM,MAAM,kBAAkB,QAAQ,KAAK,UAAU,YAAY;CACjE,MAAM,WAAW,QAAQ,UACrB,MAAM,MAAM,IAAI,QAAQ,KAAK,QAAQ,OAAO,GAAG,IAAI,IACnD,MAAM,MAAM,KAAK,IAAI;CAEzB,IAAI,qBAAqB,CAAC,SAAS,IACjC,MAAM,IAAI,WACR,QAAQ,SAAS,OAAO,IAAI,SAAS,cACrC,QACF;CAGF,IAAI,WAAW,KAAA,GACb,OAAO;CAGT,MAAM,MAAe,MAAM,SAAS,KAAK;CACzC,IAAI,wBACF,OAAO,MAAM,iBAAiB,QAAQ,KAAK,EAAE,cAAc,KAAK,CAAC;CAEnE,OAAO,MAAM,iBAAiB,QAAQ,KAAK,EAAE,cAAc,MAAM,CAAC;AACpE"}

package/dist/methods.d.mts

@@ -1,23 +1,22 @@
 import { $Fetch } from "./types.mjs";
-
 //#region src/methods.d.ts
 /**
-* Creates an HTTP method helper bound to a fetch function.
-*
-* The returned function mirrors `$Fetch` overloads but forces the provided
-* HTTP method (`GET`, `POST`, etc.) into request options.
-*
-* @param fetchFn - Fetch function to wrap.
-* @param method - HTTP method to enforce.
-* @returns Method-bound fetch function.
-* @throws Any error thrown or rejected by `fetchFn` when the returned method-bound
-*   fetch function is called.
-*
-* @example
-* const get = createMethod($fetch, "GET");
-* const user = await get("/users/1", UserSchema);
-*/
-declare function createMethod<TFetch extends $Fetch>(fetchFn: TFetch, method: string): $Fetch;
+ * Creates an HTTP method helper bound to a fetch function.
+ *
+ * The returned function mirrors `$Fetch` overloads but forces the provided
+ * HTTP method (`GET`, `POST`, etc.) into request options.
+ *
+ * @param fetchFn - Fetch function to wrap.
+ * @param method - HTTP method to enforce.
+ * @returns Method-bound fetch function.
+ * @throws {unknown} Any error thrown or rejected by `fetchFn` when the returned method-bound
+ *   fetch function is called.
+ *
+ * @example
+ * const get = createMethod($fetch, "GET");
+ * const user = await get("/users/1", UserSchema);
+ */
+declare const createMethod: (fetchFn: $Fetch, method: string) => $Fetch;
 //#endregion
 export { createMethod };
 //# sourceMappingURL=methods.d.mts.map

package/dist/methods.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"methods.d.mts","names":[],"sources":["../src/methods.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;iBAAgB,YAAA,gBAA4B,MAAA,CAAA,CAAQ,OAAA,EAAS,MAAA,EAAQ,MAAA,WAAiB,MAAA"}
+{"version":3,"file":"methods.d.mts","names":[],"sources":["../src/methods.ts"],"mappings":";;;;;;;;;;;;;;;;;;cA2Ba,eAAgB,SAAS,QAAQ,mBAAiB"}

package/dist/methods.mjs

@@ -14,44 +14,44 @@ import { isStandardSchema } from "@zap-studio/validation";
 * @param fetchFn - Fetch function to wrap.
 * @param method - HTTP method to enforce.
 * @returns Method-bound fetch function.
-* @throws Any error thrown or rejected by `fetchFn` when the returned method-bound
+* @throws {unknown} Any error thrown or rejected by `fetchFn` when the returned method-bound
 *   fetch function is called.
 *
 * @example
 * const get = createMethod($fetch, "GET");
 * const user = await get("/users/1", UserSchema);
 */
-function createMethod(fetchFn, method) {
+const createMethod = (fetchFn, method) => {
 	/**
 	* Method-bound `$Fetch` implementation.
 	*
 	* Resolves schema/option overloads and injects the configured HTTP method.
 	*/
-	function methodFetch(input, schemaOrOptions, optionsOrUndefined) {
+	async function methodFetch(input, schemaOrOptions, optionsOrUndefined) {
 		if (isStandardSchema(schemaOrOptions)) {
-			if (optionsOrUndefined?.throwOnValidationError === false) return fetchFn(input, schemaOrOptions, {
+			if (optionsOrUndefined?.throwOnValidationError === false) return await fetchFn(input, schemaOrOptions, {
 				...optionsOrUndefined,
 				method,
 				throwOnValidationError: false
 			});
 			const { throwOnValidationError, ...restOptions } = optionsOrUndefined ?? {};
-			if (throwOnValidationError === true) return fetchFn(input, schemaOrOptions, {
+			if (throwOnValidationError === true) return await fetchFn(input, schemaOrOptions, {
 				...restOptions,
 				method,
 				throwOnValidationError: true
 			});
-			return fetchFn(input, schemaOrOptions, {
+			return await fetchFn(input, schemaOrOptions, {
 				...restOptions,
 				method
 			});
 		}
-		return fetchFn(input, {
+		return await fetchFn(input, {
 			...schemaOrOptions,
 			method
 		});
 	}
 	return methodFetch;
-}
+};
 //#endregion
 export { createMethod };
 

package/dist/methods.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"methods.mjs","names":[],"sources":["../src/methods.ts"],"sourcesContent":["/**\n * Method helper factories used to build verb-specific fetch functions.\n *\n * @module @zap-studio/fetch/methods\n */\n\nimport { isStandardSchema, type StandardSchemaV1 } from \"@zap-studio/validation\";\n\nimport type { $Fetch, ExtendedRequestInit, FetchInput } from \"./types.js\";\n\n/**\n * Creates an HTTP method helper bound to a fetch function.\n *\n * The returned function mirrors `$Fetch` overloads but forces the provided\n * HTTP method (`GET`, `POST`, etc.) into request options.\n *\n * @param fetchFn - Fetch function to wrap.\n * @param method - HTTP method to enforce.\n * @returns Method-bound fetch function.\n * @throws Any error thrown or rejected by `fetchFn` when the returned method-bound\n *   fetch function is called.\n *\n * @example\n * const get = createMethod($fetch, \"GET\");\n * const user = await get(\"/users/1\", UserSchema);\n */\nexport function createMethod<TFetch extends $Fetch>(fetchFn: TFetch, method: string): $Fetch {\n  function methodFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options: ExtendedRequestInit & {\n      throwOnValidationError: false;\n    },\n  ): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\n  function methodFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options?: ExtendedRequestInit & {\n      throwOnValidationError?: true;\n    },\n  ): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\n  function methodFetch(input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;\n\n  /**\n   * Method-bound `$Fetch` implementation.\n   *\n   * Resolves schema/option overloads and injects the configured HTTP method.\n   */\n  function methodFetch(\n    input: FetchInput,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit,\n  ): Promise<unknown> {\n    if (isStandardSchema(schemaOrOptions)) {\n      if (optionsOrUndefined?.throwOnValidationError === false) {\n        return fetchFn(input, schemaOrOptions, {\n          ...optionsOrUndefined,\n          method,\n          throwOnValidationError: false,\n        });\n      }\n\n      const { throwOnValidationError, ...restOptions } = optionsOrUndefined ?? {};\n\n      if (throwOnValidationError === true) {\n        return fetchFn(input, schemaOrOptions, {\n          ...restOptions,\n          method,\n          throwOnValidationError: true,\n        });\n      }\n\n      return fetchFn(input, schemaOrOptions, {\n        ...restOptions,\n        method,\n      });\n    }\n\n    return fetchFn(input, {\n      ...schemaOrOptions,\n      method,\n    });\n  }\n\n  return methodFetch;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAoC,SAAiB,QAAwB;;;;;;CAwB3F,SAAS,YACP,OACA,iBACA,oBACkB;AAClB,MAAI,iBAAiB,gBAAgB,EAAE;AACrC,OAAI,oBAAoB,2BAA2B,MACjD,QAAO,QAAQ,OAAO,iBAAiB;IACrC,GAAG;IACH;IACA,wBAAwB;IACzB,CAAC;GAGJ,MAAM,EAAE,wBAAwB,GAAG,gBAAgB,sBAAsB,EAAE;AAE3E,OAAI,2BAA2B,KAC7B,QAAO,QAAQ,OAAO,iBAAiB;IACrC,GAAG;IACH;IACA,wBAAwB;IACzB,CAAC;AAGJ,UAAO,QAAQ,OAAO,iBAAiB;IACrC,GAAG;IACH;IACD,CAAC;;AAGJ,SAAO,QAAQ,OAAO;GACpB,GAAG;GACH;GACD,CAAC;;AAGJ,QAAO"}
+{"version":3,"file":"methods.mjs","names":[],"sources":["../src/methods.ts"],"sourcesContent":["/**\n * Method helper factories used to build verb-specific fetch functions.\n *\n * @module @zap-studio/fetch/methods\n */\n\nimport { isStandardSchema } from \"@zap-studio/validation\";\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\n\nimport type { $Fetch, ExtendedRequestInit, FetchInput } from \"./types.js\";\n\n/**\n * Creates an HTTP method helper bound to a fetch function.\n *\n * The returned function mirrors `$Fetch` overloads but forces the provided\n * HTTP method (`GET`, `POST`, etc.) into request options.\n *\n * @param fetchFn - Fetch function to wrap.\n * @param method - HTTP method to enforce.\n * @returns Method-bound fetch function.\n * @throws {unknown} Any error thrown or rejected by `fetchFn` when the returned method-bound\n *   fetch function is called.\n *\n * @example\n * const get = createMethod($fetch, \"GET\");\n * const user = await get(\"/users/1\", UserSchema);\n */\nexport const createMethod = (fetchFn: $Fetch, method: string): $Fetch => {\n  function methodFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options: ExtendedRequestInit & {\n      throwOnValidationError: false;\n    }\n  ): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\n  function methodFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options?: ExtendedRequestInit & {\n      throwOnValidationError?: true;\n    }\n  ): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\n  function methodFetch(\n    input: FetchInput,\n    options?: ExtendedRequestInit\n  ): Promise<Response>;\n\n  /**\n   * Method-bound `$Fetch` implementation.\n   *\n   * Resolves schema/option overloads and injects the configured HTTP method.\n   */\n  async function methodFetch(\n    input: FetchInput,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit\n  ): Promise<unknown> {\n    if (isStandardSchema(schemaOrOptions)) {\n      if (optionsOrUndefined?.throwOnValidationError === false) {\n        return await fetchFn(input, schemaOrOptions, {\n          ...optionsOrUndefined,\n          method,\n          throwOnValidationError: false,\n        });\n      }\n\n      const { throwOnValidationError, ...restOptions } =\n        optionsOrUndefined ?? {};\n\n      if (throwOnValidationError === true) {\n        return await fetchFn(input, schemaOrOptions, {\n          ...restOptions,\n          method,\n          throwOnValidationError: true,\n        });\n      }\n\n      return await fetchFn(input, schemaOrOptions, {\n        ...restOptions,\n        method,\n      });\n    }\n\n    return await fetchFn(input, {\n      ...schemaOrOptions,\n      method,\n    });\n  }\n\n  return methodFetch;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,gBAAgB,SAAiB,WAA2B;;;;;;CA2BvE,eAAe,YACb,OACA,iBACA,oBACkB;EAClB,IAAI,iBAAiB,eAAe,GAAG;GACrC,IAAI,oBAAoB,2BAA2B,OACjD,OAAO,MAAM,QAAQ,OAAO,iBAAiB;IAC3C,GAAG;IACH;IACA,wBAAwB;GAC1B,CAAC;GAGH,MAAM,EAAE,wBAAwB,GAAG,gBACjC,sBAAsB,CAAC;GAEzB,IAAI,2BAA2B,MAC7B,OAAO,MAAM,QAAQ,OAAO,iBAAiB;IAC3C,GAAG;IACH;IACA,wBAAwB;GAC1B,CAAC;GAGH,OAAO,MAAM,QAAQ,OAAO,iBAAiB;IAC3C,GAAG;IACH;GACF,CAAC;EACH;EAEA,OAAO,MAAM,QAAQ,OAAO;GAC1B,GAAG;GACH;EACF,CAAC;CACH;CAEA,OAAO;AACT"}

package/dist/request.d.mts

@@ -1,31 +1,30 @@
 import { ExtendedRequestInit, FetchInput } from "./types.mjs";
-
 //#region src/request.d.ts
 /**
-* Normalized representation used by internal request execution.
-*
-* - `url`: resolved string URL from the input (string or `URL`; `Request` uses `request.url`)
-* - `request`: original Request clone when input is a Request
-* - `options`: normalized request options merged with Request headers
-*/
+ * Normalized representation used by internal request execution.
+ *
+ * - `url`: resolved string URL from the input (string or `URL`; `Request` uses `request.url`)
+ * - `request`: original Request clone when input is a Request
+ * - `options`: normalized request options merged with Request headers
+ */
 interface NormalizedRequest {
   url: string;
   request?: Request;
   options: ExtendedRequestInit;
 }
 /**
-* Normalizes fetch `input` and request-level options into a consistent internal shape.
-*
-* @param input - Request URL/path or Request instance.
-* @param options - Optional request options.
-* @returns A normalized request structure for internal processing.
-* @throws {TypeError} When cloning a `Request` fails or the merged headers are invalid.
-*
-* @example
-* const normalized = normalizeRequest("/users", { method: "GET" });
-* console.log(normalized.url); // "/users"
-*/
-declare function normalizeRequest(input: FetchInput, options?: ExtendedRequestInit): NormalizedRequest;
+ * Normalizes fetch `input` and request-level options into a consistent internal shape.
+ *
+ * @param input - Request URL/path or Request instance.
+ * @param options - Optional request options.
+ * @returns A normalized request structure for internal processing.
+ * @throws {TypeError} When cloning a `Request` fails or the merged headers are invalid.
+ *
+ * @example
+ * const normalized = normalizeRequest("/users", { method: "GET" });
+ * console.log(normalized.url); // "/users"
+ */
+declare const normalizeRequest: (input: FetchInput, options?: ExtendedRequestInit) => NormalizedRequest;
 //#endregion
 export { NormalizedRequest, normalizeRequest };
 //# sourceMappingURL=request.d.mts.map

package/dist/request.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"request.d.mts","names":[],"sources":["../src/request.ts"],"mappings":";;;;;AAkBA;;;;;UAAiB,iBAAA;EACf,GAAA;EACA,OAAA,GAAU,OAAA;EACV,OAAA,EAAS,mBAAA;AAAA;;AAeX;;;;;;;;;;;iBAAgB,gBAAA,CACd,KAAA,EAAO,UAAA,EACP,OAAA,GAAU,mBAAA,GACT,iBAAA"}
+{"version":3,"file":"request.d.mts","names":[],"sources":["../src/request.ts"],"mappings":";;;;;;;;;UAkBiB;EACf;EACA,UAAU;EACV,SAAS;;;;;;;;;;;;;;cAeE,mBACX,OAAO,YACP,UAAU,wBACT"}

package/dist/request.mjs

@@ -18,22 +18,25 @@ const EMPTY_OPTIONS = {};
 * const normalized = normalizeRequest("/users", { method: "GET" });
 * console.log(normalized.url); // "/users"
 */
-function normalizeRequest(input, options) {
-	if (!(input instanceof Request)) return {
-		url: input instanceof URL ? input.href : input,
-		options: options ?? EMPTY_OPTIONS
-	};
+const normalizeRequest = (input, options) => {
+	if (!(input instanceof Request)) {
+		const url = input instanceof URL ? input.href : input;
+		return {
+			options: options ?? EMPTY_OPTIONS,
+			url
+		};
+	}
 	const request = new Request(input);
-	const { headers, ...rest } = options || {};
+	const { headers, ...rest } = options ?? {};
 	const mergedHeaders = mergeHeaders(request.headers, headers);
 	const normalizedOptions = { ...rest };
-	if (mergedHeaders) normalizedOptions.headers = mergedHeaders;
+	if (mergedHeaders !== void 0) normalizedOptions.headers = mergedHeaders;
 	return {
-		url: request.url,
+		options: normalizedOptions,
 		request,
-		options: normalizedOptions
+		url: request.url
 	};
-}
+};
 //#endregion
 export { normalizeRequest };
 

package/dist/request.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"request.mjs","names":[],"sources":["../src/request.ts"],"sourcesContent":["/**\n * Request normalization helpers for fetch `input` values.\n *\n * @module @zap-studio/fetch/request\n */\n\nimport { mergeHeaders } from \"./headers.js\";\nimport type { ExtendedRequestInit, FetchInput } from \"./types.js\";\n\nconst EMPTY_OPTIONS = {} as ExtendedRequestInit;\n\n/**\n * Normalized representation used by internal request execution.\n *\n * - `url`: resolved string URL from the input (string or `URL`; `Request` uses `request.url`)\n * - `request`: original Request clone when input is a Request\n * - `options`: normalized request options merged with Request headers\n */\nexport interface NormalizedRequest {\n  url: string;\n  request?: Request;\n  options: ExtendedRequestInit;\n}\n\n/**\n * Normalizes fetch `input` and request-level options into a consistent internal shape.\n *\n * @param input - Request URL/path or Request instance.\n * @param options - Optional request options.\n * @returns A normalized request structure for internal processing.\n * @throws {TypeError} When cloning a `Request` fails or the merged headers are invalid.\n *\n * @example\n * const normalized = normalizeRequest(\"/users\", { method: \"GET\" });\n * console.log(normalized.url); // \"/users\"\n */\nexport function normalizeRequest(\n  input: FetchInput,\n  options?: ExtendedRequestInit,\n): NormalizedRequest {\n  if (!(input instanceof Request)) {\n    const url = input instanceof URL ? input.href : input;\n    return {\n      url,\n      options: options ?? EMPTY_OPTIONS,\n    };\n  }\n\n  const request = new Request(input);\n  const { headers, ...rest } = options || {};\n  const mergedHeaders = mergeHeaders(request.headers, headers);\n  const normalizedOptions = { ...rest } as ExtendedRequestInit;\n\n  if (mergedHeaders) {\n    normalizedOptions.headers = mergedHeaders;\n  }\n\n  return {\n    url: request.url,\n    request,\n    options: normalizedOptions,\n  };\n}\n"],"mappings":";;;;;;;AASA,MAAM,gBAAgB,EAAE;;;;;;;;;;;;;AA2BxB,SAAgB,iBACd,OACA,SACmB;AACnB,KAAI,EAAE,iBAAiB,SAErB,QAAO;EACL,KAFU,iBAAiB,MAAM,MAAM,OAAO;EAG9C,SAAS,WAAW;EACrB;CAGH,MAAM,UAAU,IAAI,QAAQ,MAAM;CAClC,MAAM,EAAE,SAAS,GAAG,SAAS,WAAW,EAAE;CAC1C,MAAM,gBAAgB,aAAa,QAAQ,SAAS,QAAQ;CAC5D,MAAM,oBAAoB,EAAE,GAAG,MAAM;AAErC,KAAI,cACF,mBAAkB,UAAU;AAG9B,QAAO;EACL,KAAK,QAAQ;EACb;EACA,SAAS;EACV"}
+{"version":3,"file":"request.mjs","names":[],"sources":["../src/request.ts"],"sourcesContent":["/**\n * Request normalization helpers for fetch `input` values.\n *\n * @module @zap-studio/fetch/request\n */\n\nimport { mergeHeaders } from \"./headers.js\";\nimport type { ExtendedRequestInit, FetchInput } from \"./types.js\";\n\nconst EMPTY_OPTIONS = {} as ExtendedRequestInit;\n\n/**\n * Normalized representation used by internal request execution.\n *\n * - `url`: resolved string URL from the input (string or `URL`; `Request` uses `request.url`)\n * - `request`: original Request clone when input is a Request\n * - `options`: normalized request options merged with Request headers\n */\nexport interface NormalizedRequest {\n  url: string;\n  request?: Request;\n  options: ExtendedRequestInit;\n}\n\n/**\n * Normalizes fetch `input` and request-level options into a consistent internal shape.\n *\n * @param input - Request URL/path or Request instance.\n * @param options - Optional request options.\n * @returns A normalized request structure for internal processing.\n * @throws {TypeError} When cloning a `Request` fails or the merged headers are invalid.\n *\n * @example\n * const normalized = normalizeRequest(\"/users\", { method: \"GET\" });\n * console.log(normalized.url); // \"/users\"\n */\nexport const normalizeRequest = (\n  input: FetchInput,\n  options?: ExtendedRequestInit\n): NormalizedRequest => {\n  if (!(input instanceof Request)) {\n    const url = input instanceof URL ? input.href : input;\n    return {\n      options: options ?? EMPTY_OPTIONS,\n      url,\n    };\n  }\n\n  const request = new Request(input);\n  const { headers, ...rest } = options ?? {};\n  const mergedHeaders = mergeHeaders(request.headers, headers);\n  const normalizedOptions = { ...rest } as ExtendedRequestInit;\n\n  if (mergedHeaders !== undefined) {\n    normalizedOptions.headers = mergedHeaders;\n  }\n\n  return {\n    options: normalizedOptions,\n    request,\n    url: request.url,\n  };\n};\n"],"mappings":";;;;;;;AASA,MAAM,gBAAgB,CAAC;;;;;;;;;;;;;AA2BvB,MAAa,oBACX,OACA,YACsB;CACtB,IAAI,EAAE,iBAAiB,UAAU;EAC/B,MAAM,MAAM,iBAAiB,MAAM,MAAM,OAAO;EAChD,OAAO;GACL,SAAS,WAAW;GACpB;EACF;CACF;CAEA,MAAM,UAAU,IAAI,QAAQ,KAAK;CACjC,MAAM,EAAE,SAAS,GAAG,SAAS,WAAW,CAAC;CACzC,MAAM,gBAAgB,aAAa,QAAQ,SAAS,OAAO;CAC3D,MAAM,oBAAoB,EAAE,GAAG,KAAK;CAEpC,IAAI,kBAAkB,KAAA,GACpB,kBAAkB,UAAU;CAG9B,OAAO;EACL,SAAS;EACT;EACA,KAAK,QAAQ;CACf;AACF"}

package/dist/types.d.mts

@@ -1,9 +1,8 @@
 import { StandardSchemaV1 } from "@zap-studio/validation";
-
 //#region src/types.d.ts
 /**
-* Accepted `fetch` input type (`string`, `URL`, or `Request`).
-*/
+ * Accepted `fetch` input type (`string`, `URL`, or `Request`).
+ */
 type FetchInput = Parameters<typeof fetch>[0];
 type URLSearchParamsInput = ConstructorParameters<typeof URLSearchParams>[0];
 type RequestBodyInit = RequestInit & {
@@ -11,157 +10,157 @@ type RequestBodyInit = RequestInit & {
 };
 type JsonBodyInit = Omit<RequestInit, "body"> & {
   /**
-  * JSON body convenience. When provided, this is JSON-stringified into `body`.
-  * @default undefined
-  */
+   * JSON body convenience. When provided, this is JSON-stringified into `body`.
+   * @default undefined
+   */
   json: unknown;
   body?: never;
 };
-type CustomRequestInit = {
+interface CustomRequestInit {
   /**
-  * Per-request query/search params
-  * @default undefined
-  */
+   * Per-request query/search params
+   * @default undefined
+   */
   searchParams?: URLSearchParamsInput;
   /**
-  * Whether to throw a FetchError on HTTP errors (non-2xx responses)
-  * @default true
-  */
+   * Whether to throw a FetchError on HTTP errors (non-2xx responses)
+   * @default true
+   */
   throwOnFetchError?: boolean;
   /**
-  * Whether to throw a ValidationError on validation errors
-  * @default true
-  */
+   * Whether to throw a ValidationError on validation errors
+   * @default true
+   */
   throwOnValidationError?: boolean;
-};
+}
 /**
-* Extended RequestInit type to include custom fetch options
-*
-* @example
-* const options: ExtendedRequestInit = {
-*   method: "POST",
-*   json: { name: "Ada" },
-*   throwOnFetchError: true,
-* };
-*/
+ * Extended RequestInit type to include custom fetch options
+ *
+ * @example
+ * const options: ExtendedRequestInit = {
+ *   method: "POST",
+ *   json: { name: "Ada" },
+ *   throwOnFetchError: true,
+ * };
+ */
 type ExtendedRequestInit = (RequestBodyInit | JsonBodyInit) & CustomRequestInit;
 /**
-* Internal defaults used by fetchInternal
-*
-* @example
-* const defaults: FetchDefaults = {
-*   baseURL: "https://api.example.com",
-*   throwOnFetchError: true,
-*   throwOnValidationError: true,
-* };
-*/
+ * Internal defaults used by fetchInternal
+ *
+ * @example
+ * const defaults: FetchDefaults = {
+ *   baseURL: "https://api.example.com",
+ *   throwOnFetchError: true,
+ *   throwOnValidationError: true,
+ * };
+ */
 interface FetchDefaults {
   /**
-  * Base URL to prepend to all requests
-  * @default ""
-  */
+   * Base URL to prepend to all requests
+   * @default ""
+   */
   baseURL: string;
   /**
-  * Default headers to include in all requests (can be overridden per request)
-  * @default undefined
-  */
+   * Default headers to include in all requests (can be overridden per request)
+   * @default undefined
+   */
   headers?: HeadersInit;
   /**
-  * Default query/search params applied to every request (can be overridden per request)
-  * @default undefined
-  */
+   * Default query/search params applied to every request (can be overridden per request)
+   * @default undefined
+   */
   searchParams?: URLSearchParamsInput;
   /**
-  * Whether to throw a `FetchError` on HTTP errors (non-2xx responses)
-  * @default true
-  */
+   * Whether to throw a `FetchError` on HTTP errors (non-2xx responses)
+   * @default true
+   */
   throwOnFetchError: boolean;
   /**
-  * Whether to throw a `ValidationError` on validation errors
-  * @default true
-  */
+   * Whether to throw a `ValidationError` on validation errors
+   * @default true
+   */
   throwOnValidationError: boolean;
 }
 /**
-* Type-safe fetch function with Standard Schema validation support
-*/
+ * Type-safe fetch function with Standard Schema validation support
+ */
 interface $Fetch {
   /**
-  * Fetch with schema validation and throwOnValidationError: false
-  * @param input - URL or path to fetch
-  * @param schema - Standard Schema for response validation
-  * @param options - Extended request options with throwOnValidationError: false
-  * @returns Standard Schema Result object with value or issues
-  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
-  * @throws {TypeError} When request construction, JSON request serialization, headers,
-  *   search params, native `fetch`, or `response.json()` body reading fail with a
-  *   `TypeError`.
-  * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
-  *   request/body read as an `AbortError` DOMException.
-  * @throws {SyntaxError} When `response.json()` cannot parse the response body.
-  * @throws Any error thrown or rejected by the provided Standard Schema validator.
-  */
+   * Fetch with schema validation and throwOnValidationError: false
+   * @param input - URL or path to fetch
+   * @param schema - Standard Schema for response validation
+   * @param options - Extended request options with throwOnValidationError: false
+   * @returns Standard Schema Result object with value or issues
+   * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+   * @throws {TypeError} When request construction, JSON request serialization, headers,
+   *   search params, native `fetch`, or `response.json()` body reading fail with a
+   *   `TypeError`.
+   * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+   *   request/body read as an `AbortError` DOMException.
+   * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+   * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+   */
   <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options: ExtendedRequestInit & {
     throwOnValidationError: false;
   }): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
   /**
-  * Fetch with schema validation and throwOnValidationError: true or undefined (default)
-  * @param input - URL or path to fetch
-  * @param schema - Standard Schema for response validation
-  * @param options - Extended request options
-  * @returns Validated data of type TSchema
-  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
-  * @throws {ValidationError} When validation returns issues.
-  * @throws {TypeError} When request construction, JSON request serialization, headers,
-  *   search params, native `fetch`, or `response.json()` body reading fail with a
-  *   `TypeError`.
-  * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
-  *   request/body read as an `AbortError` DOMException.
-  * @throws {SyntaxError} When `response.json()` cannot parse the response body.
-  * @throws Any error thrown or rejected by the provided Standard Schema validator.
-  */
+   * Fetch with schema validation and throwOnValidationError: true or undefined (default)
+   * @param input - URL or path to fetch
+   * @param schema - Standard Schema for response validation
+   * @param options - Extended request options
+   * @returns Validated data of type TSchema
+   * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+   * @throws {ValidationError} When validation returns issues.
+   * @throws {TypeError} When request construction, JSON request serialization, headers,
+   *   search params, native `fetch`, or `response.json()` body reading fail with a
+   *   `TypeError`.
+   * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+   *   request/body read as an `AbortError` DOMException.
+   * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+   * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+   */
   <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options?: ExtendedRequestInit & {
     throwOnValidationError?: true;
   }): Promise<StandardSchemaV1.InferOutput<TSchema>>;
   /**
-  * Fetch without schema validation
-  * @param input - URL or path to fetch
-  * @param options - Extended request options
-  * @returns Raw Response object
-  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
-  * @throws {TypeError} When request construction, JSON request serialization, headers,
-  *   search params, or native `fetch` fail with a `TypeError`.
-  * @throws {DOMException} When native `fetch` rejects an aborted request as an
-  *   `AbortError` DOMException.
-  */
+   * Fetch without schema validation
+   * @param input - URL or path to fetch
+   * @param options - Extended request options
+   * @returns Raw Response object
+   * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+   * @throws {TypeError} When request construction, JSON request serialization, headers,
+   *   search params, or native `fetch` fail with a `TypeError`.
+   * @throws {DOMException} When native `fetch` rejects an aborted request as an
+   *   `AbortError` DOMException.
+   */
   (input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;
 }
 /**
-* API HTTP method-specific fetch functions
-*
-* @example
-* const user = await api.get("/users/1", UserSchema);
-*/
+ * API HTTP method-specific fetch functions
+ *
+ * @example
+ * const user = await api.get("/users/1", UserSchema);
+ */
 interface ApiMethods {
   /**
-  * DELETE method fetch function
-  */
+   * DELETE method fetch function
+   */
   delete: $Fetch;
   /**
-  * GET method fetch function
-  */
+   * GET method fetch function
+   */
   get: $Fetch;
   /**
-  * PATCH method fetch function
-  */
+   * PATCH method fetch function
+   */
   patch: $Fetch;
   /**
-  * POST method fetch function
-  */
+   * POST method fetch function
+   */
   post: $Fetch;
   /**
-  * PUT method fetch function
-  */
+   * PUT method fetch function
+   */
   put: $Fetch;
 }
 //#endregion

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;AAWkD;KAAtC,UAAA,GAAa,UAAA,QAAkB,KAAA;AAAA,KAEtC,oBAAA,GAAuB,qBAAA,QAA6B,eAAA;AAAA,KAEpD,eAAA,GAAkB,WAAA;EACrB,IAAA;AAAA;AAAA,KAGG,YAAA,GAAe,IAAA,CAAK,WAAA;;;;AAHvB;EAQA,IAAA;EACA,IAAA;AAAA;AAAA,KAGG,iBAAA;;;;;EAKH,YAAA,GAAe,oBAAA;EARf;;;;EAaA,iBAAA;;;;;EAKA,sBAAA;AAAA;;;;;;;;;;;KAaU,mBAAA,IAAuB,eAAA,GAAkB,YAAA,IAAgB,iBAAA;;AAYrE;;;;;;;;;UAAiB,aAAA;;;;AA+BjB;EA1BE,OAAA;;;;;EAKA,OAAA,GAAU,WAAA;;;;;EAKV,YAAA,GAAe,oBAAA;;;;;EAKf,iBAAA;;;;;EAKA,sBAAA;AAAA;;;;UAMe,MAAA;;;;;;;;;;;;;;;;mBAgBE,gBAAA,EACf,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,EAAS,mBAAA;IAAwB,sBAAA;EAAA,IAChC,OAAA,CAAQ,gBAAA,CAAiB,MAAA,CAAO,gBAAA,CAAiB,WAAA,CAAY,OAAA;;;;;;;;;;;;;;;;AA8ClE;mBA5BmB,gBAAA,EACf,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,GAAU,mBAAA;IACR,sBAAA;EAAA,IAED,OAAA,CAAQ,gBAAA,CAAiB,WAAA,CAAY,OAAA;;;;;;;;;;;;GAavC,KAAA,EAAO,UAAA,EAAY,OAAA,GAAU,mBAAA,GAAsB,OAAA,CAAQ,QAAA;AAAA;;;;;;;UAS7C,UAAA;;;;EAIf,MAAA,EAAQ,MAAA;;;;EAIR,GAAA,EAAK,MAAA;;;;EAIL,KAAA,EAAO,MAAA;;;;EAIP,IAAA,EAAM,MAAA;;;;EAIN,GAAA,EAAK,MAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;KAWY,aAAa,kBAAkB;KAEtC,uBAAuB,6BAA6B;KAEpD,kBAAkB;EACrB;;KAGG,eAAe,KAAK;;;;;EAKvB;EACA;;UAGQ;;;;;EAKR,eAAe;;;;;EAKf;;;;;EAKA;;;;;;;;;;;;KAaU,uBAAuB,kBAAkB,gBACnD;;;;;;;;;;;UAYe;;;;;EAKf;;;;;EAKA,UAAU;;;;;EAKV,eAAe;;;;;EAKf;;;;;EAKA;;;;;UAMe;;;;;;;;;;;;;;;;GAgBd,gBAAgB,kBACf,OAAO,YACP,QAAQ,SACR,SAAS;IAAwB;MAChC,QAAQ,iBAAiB,OAAO,iBAAiB,YAAY;;;;;;;;;;;;;;;;;GAkB/D,gBAAgB,kBACf,OAAO,YACP,QAAQ,SACR,UAAU;IACR;MAED,QAAQ,iBAAiB,YAAY;;;;;;;;;;;;GAavC,OAAO,YAAY,UAAU,sBAAsB,QAAQ;;;;;;;;UAS7C;;;;EAIf,QAAQ;;;;EAIR,KAAK;;;;EAIL,OAAO;;;;EAIP,MAAM;;;;EAIN,KAAK"}