@zap-studio/fetch 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @zap-studio/fetch
 
+## 0.2.0
+
+### Minor Changes
+
+- 78afb76: ### Standard Schema Support
+
+  Migrated from Zod-only validation to **Standard Schema v1** specification, enabling support for multiple validation libraries:
+
+  - Zod
+  - Valibot
+  - ArkType
+  - Any Standard Schema compliant library
+
+  ### New Features
+
+  - **Factory Pattern**: `createFetch()` for creating pre-configured fetch instances with `baseURL`, default `headers`, and error handling options
+  - **Smart URL Handling**: Absolute URLs bypass `baseURL` configuration
+  - **Auto JSON Body**: Automatic `JSON.stringify()` and `Content-Type` header when using schemas with request bodies
+
+  ### Breaking Changes
+
+  - Schema validation now requires Standard Schema compliant libraries (Zod 3.23+, Valibot 1.0+, ArkType 2.0+)
+  - Internal file structure reorganized (affects deep imports if any were used)
+  - `FetchError` constructor signature changed: now requires `(message, response)`
+
+  ### Migration Guide
+
+  ```typescript
+  // Before (Zod-only)
+  import { $fetch } from "@zap-studio/fetch";
+  import { z } from "zod";
+
+  // After (Standard Schema - works the same with Zod!)
+  import { $fetch } from "@zap-studio/fetch";
+  import { z } from "zod"; // Zod 3.23+ is Standard Schema compliant
+
+  // Or use other libraries
+  import * as v from "valibot";
+  import { type } from "arktype";
+  ```
+
+## 0.1.2
+
+### Patch Changes
+
+- 69c2b21: Change `safeFetch` to `$fetch` syntax and make sure `safeFetch` can also be used for legacy
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -1,22 +1,38 @@
 # @zap-studio/fetch
 
-A type-safe fetch wrapper with Zod validation for TypeScript.
+A type-safe fetch wrapper with Standard Schema validation.
+
+## Why @zap-studio/fetch?
+
+**Before:**
+
+```typescript
+const response = await fetch("/api/users/1");
+const data = await response.json();
+const user = data as User; // 😱 Unsafe type assertion
+```
+
+**After:**
+
+```typescript
+const user = await api.get("/api/users/1", UserSchema);
+// ✨ Typed, validated, and safe!
+```
 
 ## Features
 
 - 🎯 **Type-safe requests** with automatic type inference
-- 🛡️ **Runtime validation** using Zod schemas
-- 🔄 **Automatic content-type** detection and handling
+- 🛡️ **Runtime validation** using Standard Schema (Zod, Valibot, ArkType, etc.)
 - ⚡️ **Convenient API methods** (GET, POST, PUT, PATCH, DELETE)
-- 📦 **Multiple response types** (JSON, text, blob, arrayBuffer)
-- 🚨 **Custom error handling** with FetchError class
+- 🏭 **Factory pattern** for creating pre-configured instances with base URLs
+- 🚨 **Custom error handling** with FetchError and ValidationError classes
 - 📘 **Full TypeScript support** with zero configuration
 
 ## Installation
 
 ```bash
 pnpm add @zap-studio/fetch
-#or
+# or
 npm install @zap-studio/fetch
 ```
 
@@ -34,10 +50,7 @@ const UserSchema = z.object({
 });
 
 // Make a type-safe request
-const user = await api.get(
-  "https://api.example.com/users/1",
-  UserSchema
-);
+const user = await api.get("https://api.example.com/users/1", UserSchema);
 
 // user is fully typed and validated! ✨
 console.log(user.name); // TypeScript knows this is a string
@@ -51,28 +64,31 @@ console.log(user.name); // TypeScript knows this is a string
 const user = await api.get("/api/users/1", UserSchema);
 ```
 
-### `api.post(url, schema, body?, options?)`
+### `api.post(url, schema, options?)`
 
 ```typescript
 const newUser = await api.post("/api/users", UserSchema, {
-  name: "John Doe",
-  email: "john@example.com",
+  body: {
+    name: "John Doe",
+    email: "john@example.com",
+  },
 });
+// Automatically stringifies body and sets Content-Type: application/json
 ```
 
-### `api.put(url, schema, body?, options?)`
+### `api.put(url, schema, options?)`
 
 ```typescript
 const updated = await api.put("/api/users/1", UserSchema, {
-  name: "Jane Doe",
+  body: { name: "Jane Doe" },
 });
 ```
 
-### `api.patch(url, schema, body?, options?)`
+### `api.patch(url, schema, options?)`
 
 ```typescript
 const patched = await api.patch("/api/users/1", UserSchema, {
-  email: "newemail@example.com",
+  body: { email: "newemail@example.com" },
 });
 ```
 
@@ -82,88 +98,136 @@ const patched = await api.patch("/api/users/1", UserSchema, {
 const deleted = await api.delete("/api/users/1", UserSchema);
 ```
 
+> **Note:** The `api.*` methods always require a schema for validation. For raw responses without validation, use `$fetch` directly.
+
 ## Advanced Usage
 
-### Using `safeFetch` directly
+### Using `$fetch` directly
+
+For more control or when you don't need schema validation:
 
 ```typescript
-import { safeFetch } from "@zap-studio/fetch";
-
-const result = await safeFetch(
-  "https://api.example.com/users/1",
-  UserSchema,
-  {
-    method: "GET",
-    headers: {
-      "Authorization": "Bearer token",
-    },
-  }
-);
+import { $fetch } from "@zap-studio/fetch";
+
+// With schema validation
+const user = await $fetch("https://api.example.com/users/1", UserSchema, {
+  method: "GET",
+  headers: {
+    Authorization: "Bearer token",
+  },
+});
+
+// Without schema - returns raw Response object
+const response = await $fetch("https://api.example.com/users/1", {
+  method: "GET",
+});
+const data = await response.json();
+```
+
+### Factory Pattern with `createFetch`
+
+Create pre-configured fetch instances with base URLs and default headers. Useful for API clients:
+
+```typescript
+import { z } from "zod";
+import { createFetch } from "@zap-studio/fetch";
+
+// Create a configured instance
+const { $fetch, api } = createFetch({
+  baseURL: "https://api.example.com",
+  headers: {
+    Authorization: "Bearer your-token",
+    "X-API-Key": "your-api-key",
+  },
+});
+
+const UserSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+});
+
+// Now use relative paths - baseURL is prepended automatically
+const user = await api.get("/users/1", UserSchema);
+
+// POST with auto-stringified body
+const newUser = await api.post("/users", UserSchema, {
+  body: { name: "John Doe" },
+});
 ```
 
-### Custom response types
+#### Factory Options
+
+| Option                   | Type          | Default | Description                                      |
+| ------------------------ | ------------- | ------- | ------------------------------------------------ |
+| `baseURL`                | `string`      | `""`    | Base URL prepended to relative paths only        |
+| `headers`                | `HeadersInit` | -       | Default headers included in all requests         |
+| `throwOnFetchError`      | `boolean`     | `true`  | Throw `FetchError` on non-2xx responses          |
+| `throwOnValidationError` | `boolean`     | `true`  | Throw `ValidationError` on schema validation failures |
+
+> **Note:** Absolute URLs (starting with `http://`, `https://`, or `//`) are used as-is and ignore the `baseURL`.
+
+#### Multiple API Clients
+
+You can create separate fetch instances for different APIs:
 
 ```typescript
-// Get text response
-const text = await safeFetch(
-  "/api/data",
-  z.string(),
-  { responseType: "text" }
-);
-
-// Get blob response
-const blob = await safeFetch(
-  "/api/file",
-  z.instanceof(Blob),
-  { responseType: "blob" }
-);
+import { createFetch } from "@zap-studio/fetch";
+
+// GitHub API client
+const github = createFetch({
+  baseURL: "https://api.github.com",
+  headers: { Authorization: "Bearer github-token" },
+});
+
+// Your internal API client
+const internal = createFetch({
+  baseURL: "https://internal.example.com/api",
+  headers: { "X-Internal-Key": "secret" },
+});
+
+// Use them independently
+const repo = await github.api.get("/repos/owner/repo", RepoSchema);
+const data = await internal.api.get("/data", DataSchema);
 ```
 
-### Error handling
+### Error Handling
+
+The package exports specialized error classes for granular error handling:
 
 ```typescript
-import { FetchError } from "@zap-studio/fetch/errors";
+import { $fetch } from "@zap-studio/fetch";
+import { FetchError, ValidationError } from "@zap-studio/fetch/errors";
 
 try {
   const user = await api.get("/api/users/1", UserSchema);
 } catch (error) {
   if (error instanceof FetchError) {
-    console.error(`HTTP ${error.status}: ${error.statusText}`);
+    console.error(`HTTP ${error.status}: ${error.response.statusText}`);
+  }
+  if (error instanceof ValidationError) {
+    console.error("Validation failed:", error.issues);
   }
 }
 ```
 
-### Flexible validation
+### Flexible Validation
+
+You can choose whether validation errors should throw exceptions:
 
 ```typescript
 // Throw on validation error (default)
-const user = await safeFetch(url, UserSchema, {
+const user = await $fetch(url, UserSchema, {
   throwOnValidationError: true,
 });
 
 // Return validation result without throwing
-const result = await safeFetch(url, UserSchema, {
+const result = await $fetch(url, UserSchema, {
   throwOnValidationError: false,
 });
 
-if (result.success) {
-  console.log(result.data);
+if (result.issues) {
+  console.error("Validation failed:", result.issues);
 } else {
-  console.error(result.error);
+  console.log("Success:", result.value);
 }
 ```
-
-## Why @zap-studio/fetch?
-
-**Before:**
-```typescript
-const response = await fetch("/api/users/1");
-const data = await response.json();
-const user = data as User; // 😱 Unsafe type assertion
-```
-
-**After:**
-```typescript
-const user = await api.get("/api/users/1", UserSchema);
-// ✨ Typed, validated, and safe!
-```

package/dist/errors-DKxnbFHZ.mjs

@@ -0,0 +1,29 @@
+//#region src/errors.ts
+/**
+* Error thrown for HTTP errors (non-2xx responses)
+*/
+var FetchError = class extends Error {
+	status;
+	response;
+	constructor(message, response) {
+		super(message);
+		this.name = "FetchError";
+		this.status = response.status;
+		this.response = response;
+	}
+};
+/**
+* Error thrown for validation errors
+*/
+var ValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(JSON.stringify(issues, null, 2));
+		this.name = "ValidationError";
+		this.issues = issues;
+	}
+};
+
+//#endregion
+export { ValidationError as n, FetchError as t };
+//# sourceMappingURL=errors-DKxnbFHZ.mjs.map

package/dist/errors-DKxnbFHZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DKxnbFHZ.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Error thrown for HTTP errors (non-2xx responses)\n */\nexport class FetchError extends Error {\n  status: Response[\"status\"];\n  response: Response;\n\n  constructor(message: string, response: Response) {\n    super(message);\n    this.name = \"FetchError\";\n    this.status = response.status;\n    this.response = response;\n  }\n}\n\n/**\n * Error thrown for validation errors\n */\nexport class ValidationError extends Error {\n  issues: StandardSchemaV1.Issue[];\n\n  constructor(issues: StandardSchemaV1.Issue[]) {\n    super(JSON.stringify(issues, null, 2));\n    this.name = \"ValidationError\";\n    this.issues = issues;\n  }\n}\n"],"mappings":";;;;AAKA,IAAa,aAAb,cAAgC,MAAM;CACpC;CACA;CAEA,YAAY,SAAiB,UAAoB;AAC/C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS,SAAS;AACvB,OAAK,WAAW;;;;;;AAOpB,IAAa,kBAAb,cAAqC,MAAM;CACzC;CAEA,YAAY,QAAkC;AAC5C,QAAM,KAAK,UAAU,QAAQ,MAAM,EAAE,CAAC;AACtC,OAAK,OAAO;AACZ,OAAK,SAAS"}

package/dist/errors.d.mts

@@ -0,0 +1,22 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/errors.d.ts
+
+/**
+ * Error thrown for HTTP errors (non-2xx responses)
+ */
+declare class FetchError extends Error {
+  status: Response["status"];
+  response: Response;
+  constructor(message: string, response: Response);
+}
+/**
+ * Error thrown for validation errors
+ */
+declare class ValidationError extends Error {
+  issues: StandardSchemaV1.Issue[];
+  constructor(issues: StandardSchemaV1.Issue[]);
+}
+//#endregion
+export { FetchError, ValidationError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AACU,cADG,UAAA,SAAmB,KAAA,CACtB;EACE,MAAA,EADF,QACE,CAAA,QAAA,CAAA;EAE6B,QAAA,EAF7B,QAE6B;EAJT,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,EAIS,QAJT;;AAehC;;;AAAqC,cAAxB,eAAA,SAAwB,KAAA,CAAA;EAAK,MAAA,EAChC,gBAAA,CAAiB,KADe,EAAA;sBAGpB,gBAAA,CAAiB"}

package/dist/errors.mjs

@@ -0,0 +1,3 @@
+import { n as ValidationError, t as FetchError } from "./errors-DKxnbFHZ.mjs";
+
+export { FetchError, ValidationError };

package/dist/index.d.mts

@@ -0,0 +1,102 @@
+import { n as ExtendedRequestInit, t as CreateFetchOptions } from "./types-C0Uhh2KM.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/index.d.ts
+
+/**
+ * Type-safe fetch wrapper with Standard Schema validation.
+ *
+ * - When `throwOnValidationError: true`: validated data of type `TSchema`
+ * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`
+ * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses
+ *
+ * If no schema is provided, returns the raw `Response` object.
+ *
+ * @throws {FetchError} When `throwOnFetchError: true` and response is not ok
+ * @throws {ValidationError} When `throwOnValidationError: true` and validation fails
+ *
+ * @example
+ * import { z } from "zod";
+ * import { $fetch } from "@zap-studio/fetch";
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Basic usage (schema validation)
+ * const user = await $fetch("/api/users/1", UserSchema, { headers: { "Authorization": "Bearer token" } });
+ * console.log("Validated user:", user);
+ *
+ * // Raw usage (no schema validation and typed Response object)
+ * const result = await $fetch("/api/data", { method: "POST", body: JSON.stringify({ key: "value" }) });
+ * const json = await result.json() as ResultType;
+ * console.log("Raw response data:", json);
+ *
+ * // Usage with validation errors returned instead of thrown
+ * const result = await $fetch("/api/users/1", UserSchema, { throwOnValidationError: false });
+ *
+ * if (result.issues) {
+ *   console.error("Validation errors:", result.issues);
+ * } else {
+ *   console.log("Validated user:", result.value);
+ * }
+ */
+declare function $fetch<TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: ExtendedRequestInit): Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+declare function $fetch(resource: string, options?: ExtendedRequestInit): Promise<Response>;
+/**
+ * Convenience methods for common HTTP verbs.
+ *
+ * These methods always require a schema for validation.
+ * For raw responses without validation, use `$fetch` directly.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { api } from "@zap-studio/fetch";
+ *
+ * const PostSchema = z.object({
+ *   id: z.number(),
+ *   title: z.string(),
+ *   content: z.string(),
+ * });
+ *
+ * async function fetchPost(postId: number) {
+ *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+ *   return post; // post is typed as { id: number; title: string; content: string; }
+ * }
+ */
+declare const api: {
+  get: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  post: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  put: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  patch: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  delete: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+};
+/**
+ * Creates a custom fetch instance with pre-configured defaults.
+ *
+ * Use this factory to create API clients with a base URL, default headers,
+ * and other shared configuration. Each instance is independent.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { createFetch } from "@zap-studio/fetch";
+ *
+ * // Create a configured instance
+ * const { $fetch, api } = createFetch({
+ *   baseURL: "https://api.example.com",
+ *   headers: { "Authorization": "Bearer token" },
+ * });
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Now use relative paths - baseURL is prepended automatically
+ * const user = await api.get("/users/1", UserSchema);
+ *
+ * // Or use $fetch directly
+ * const response = await $fetch("/users", UserSchema, { method: "POST", body: { name: "John" } });
+ */
+declare function createFetch(factoryOptions?: CreateFetchOptions): {
+  $fetch: typeof $fetch;
+  api: typeof api;
+};
+//#endregion
+export { $fetch, api, createFetch };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AA8CA;;;;;;;;;;;AASA;;;;;AAsCA;;;;;;;;;;;;;;;;;;iBA/CsB,uBAAuB,4CAEnC,mBACE,sBACT,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY;iBAGnC,MAAA,6BAEV,sBACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;cAmCE;;;;;;;;;;;AAgCb;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,kBAA4B;iBAC3B;cACH"}

package/dist/index.mjs

@@ -0,0 +1,172 @@
+import { t as FetchError } from "./errors-DKxnbFHZ.mjs";
+import { n as standardValidate, t as isStandardSchema } from "./validator-BGjWrM4d.mjs";
+
+//#region src/internal/constants.ts
+/**
+* Default options for the global $fetch
+*/
+const GLOBAL_DEFAULTS = {
+	baseURL: "",
+	headers: void 0,
+	throwOnFetchError: true,
+	throwOnValidationError: true
+};
+
+//#endregion
+//#region src/internal/utils.ts
+/**
+* Merges two HeadersInit objects, with the second one taking precedence
+*
+* @example
+* const baseHeaders = { "Authorization": "Bearer token", "Content-Type": "application/json" };
+* const overrideHeaders = { "Content-Type": "application/xml", "X-Custom-Header": "value" };
+*
+* const merged = mergeHeaders(baseHeaders, overrideHeaders);
+*
+* // Resulting headers:
+* // {
+* //   "Authorization": "Bearer token",
+* //   "Content-Type": "application/xml",
+* //   "X-Custom-Header": "value"
+* // }
+*/
+function mergeHeaders(base, override) {
+	if (!(base || override)) return;
+	const merged = new Headers(base);
+	if (override) {
+		const overrideHeaders = new Headers(override);
+		for (const [key, value] of overrideHeaders.entries()) merged.set(key, value);
+	}
+	return merged;
+}
+const TRAILING_SLASHES = /\/+$/;
+const LEADING_SLASHES = /^\/+/;
+const ABSOLUTE_URL_PATTERN = /^(https?:)?\/\//i;
+/**
+* Checks if a URL is absolute (starts with http://, https://, or //)
+*/
+function isAbsoluteURL(url) {
+	return ABSOLUTE_URL_PATTERN.test(url);
+}
+/**
+* Internal fetch implementation used by both $fetch and createFetch
+*/
+async function fetchInternal(resource, schema, options, defaults) {
+	const { throwOnValidationError = defaults.throwOnValidationError, throwOnFetchError = defaults.throwOnFetchError, headers: requestHeaders, ...rest } = options || {};
+	const mergedHeaders = mergeHeaders(defaults.headers, requestHeaders);
+	const init = {
+		...rest,
+		headers: mergedHeaders
+	};
+	if (schema && init.body) {
+		init.body = JSON.stringify(init.body);
+		const existingHeaders = new Headers(init.headers);
+		if (!existingHeaders.has("Content-Type")) existingHeaders.set("Content-Type", "application/json");
+		init.headers = existingHeaders;
+	}
+	let url;
+	if (isAbsoluteURL(resource)) url = resource;
+	else {
+		const base = defaults.baseURL.replace(TRAILING_SLASHES, "");
+		const path = resource.replace(LEADING_SLASHES, "");
+		url = base ? `${base}/${path}` : resource;
+	}
+	const response = await fetch(url, init);
+	if (throwOnFetchError && !response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response);
+	if (schema) return standardValidate(schema, await response.json(), throwOnValidationError);
+	return response;
+}
+/**
+* Creates an HTTP method helper bound to a fetch function
+*/
+function createMethod(fetchFn, method) {
+	return (resource, schema, options) => fetchFn(resource, schema, {
+		...options,
+		method
+	});
+}
+
+//#endregion
+//#region src/index.ts
+async function $fetch(resource, schemaOrOptions, optionsOrUndefined) {
+	const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
+	return await fetchInternal(resource, schema, options, GLOBAL_DEFAULTS);
+}
+/**
+* Convenience methods for common HTTP verbs.
+*
+* These methods always require a schema for validation.
+* For raw responses without validation, use `$fetch` directly.
+*
+* @example
+* import { z } from "zod";
+* import { api } from "@zap-studio/fetch";
+*
+* const PostSchema = z.object({
+*   id: z.number(),
+*   title: z.string(),
+*   content: z.string(),
+* });
+*
+* async function fetchPost(postId: number) {
+*   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+*   return post; // post is typed as { id: number; title: string; content: string; }
+* }
+*/
+const api = {
+	get: createMethod($fetch, "GET"),
+	post: createMethod($fetch, "POST"),
+	put: createMethod($fetch, "PUT"),
+	patch: createMethod($fetch, "PATCH"),
+	delete: createMethod($fetch, "DELETE")
+};
+/**
+* Creates a custom fetch instance with pre-configured defaults.
+*
+* Use this factory to create API clients with a base URL, default headers,
+* and other shared configuration. Each instance is independent.
+*
+* @example
+* import { z } from "zod";
+* import { createFetch } from "@zap-studio/fetch";
+*
+* // Create a configured instance
+* const { $fetch, api } = createFetch({
+*   baseURL: "https://api.example.com",
+*   headers: { "Authorization": "Bearer token" },
+* });
+*
+* const UserSchema = z.object({ id: z.number(), name: z.string() });
+*
+* // Now use relative paths - baseURL is prepended automatically
+* const user = await api.get("/users/1", UserSchema);
+*
+* // Or use $fetch directly
+* const response = await $fetch("/users", UserSchema, { method: "POST", body: { name: "John" } });
+*/
+function createFetch(factoryOptions = {}) {
+	const defaults = {
+		baseURL: factoryOptions.baseURL ?? "",
+		headers: factoryOptions.headers,
+		throwOnFetchError: factoryOptions.throwOnFetchError ?? true,
+		throwOnValidationError: factoryOptions.throwOnValidationError ?? true
+	};
+	async function customFetch(resource, schemaOrOptions, optionsOrUndefined) {
+		const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
+		return await fetchInternal(resource, schema, options, defaults);
+	}
+	return {
+		$fetch: customFetch,
+		api: {
+			get: createMethod(customFetch, "GET"),
+			post: createMethod(customFetch, "POST"),
+			put: createMethod(customFetch, "PUT"),
+			patch: createMethod(customFetch, "PATCH"),
+			delete: createMethod(customFetch, "DELETE")
+		}
+	};
+}
+
+//#endregion
+export { $fetch, api, createFetch };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["url: string","defaults: FetchDefaults"],"sources":["../src/internal/constants.ts","../src/internal/utils.ts","../src/index.ts"],"sourcesContent":["import type { FetchDefaults } from \"../types\";\n\n/**\n * Default options for the global $fetch\n */\nexport const GLOBAL_DEFAULTS = {\n  baseURL: \"\",\n  headers: undefined,\n  throwOnFetchError: true,\n  throwOnValidationError: true,\n} as const satisfies FetchDefaults;\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { $fetch } from \"..\";\nimport { FetchError } from \"../errors\";\nimport type { ExtendedRequestInit, FetchDefaults } from \"../types\";\nimport { standardValidate } from \"../validator\";\n\n/**\n * Merges two HeadersInit objects, with the second one taking precedence\n *\n * @example\n * const baseHeaders = { \"Authorization\": \"Bearer token\", \"Content-Type\": \"application/json\" };\n * const overrideHeaders = { \"Content-Type\": \"application/xml\", \"X-Custom-Header\": \"value\" };\n *\n * const merged = mergeHeaders(baseHeaders, overrideHeaders);\n *\n * // Resulting headers:\n * // {\n * //   \"Authorization\": \"Bearer token\",\n * //   \"Content-Type\": \"application/xml\",\n * //   \"X-Custom-Header\": \"value\"\n * // }\n */\nexport function mergeHeaders(\n  base: HeadersInit | undefined,\n  override: HeadersInit | undefined\n): Headers | undefined {\n  if (!(base || override)) {\n    return;\n  }\n\n  const merged = new Headers(base);\n  if (override) {\n    const overrideHeaders = new Headers(override);\n    for (const [key, value] of overrideHeaders.entries()) {\n      merged.set(key, value);\n    }\n  }\n  return merged;\n}\n\nconst TRAILING_SLASHES = /\\/+$/;\nconst LEADING_SLASHES = /^\\/+/;\nconst ABSOLUTE_URL_PATTERN = /^(https?:)?\\/\\//i;\n\n/**\n * Checks if a URL is absolute (starts with http://, https://, or //)\n */\nfunction isAbsoluteURL(url: string): boolean {\n  return ABSOLUTE_URL_PATTERN.test(url);\n}\n\n/**\n * Internal fetch implementation used by both $fetch and createFetch\n */\nexport async function fetchInternal(\n  resource: string,\n  schema: StandardSchemaV1 | undefined,\n  options: ExtendedRequestInit | undefined,\n  defaults: FetchDefaults\n): Promise<unknown> {\n  const {\n    throwOnValidationError = defaults.throwOnValidationError,\n    throwOnFetchError = defaults.throwOnFetchError,\n    headers: requestHeaders,\n    ...rest\n  } = options || {};\n\n  const mergedHeaders = mergeHeaders(defaults.headers, requestHeaders);\n  const init = { ...rest, headers: mergedHeaders } as RequestInit;\n\n  // Auto-stringify body and set default Content-Type if we have a schema\n  if (schema && init.body) {\n    init.body = JSON.stringify(init.body);\n\n    const existingHeaders = new Headers(init.headers);\n    if (!existingHeaders.has(\"Content-Type\")) {\n      existingHeaders.set(\"Content-Type\", \"application/json\");\n    }\n\n    init.headers = existingHeaders;\n  }\n\n  // For absolute URLs, ignore baseURL entirely\n  let url: string;\n  if (isAbsoluteURL(resource)) {\n    url = resource;\n  } else {\n    // Normalize URL by avoiding double slashes between baseURL and resource\n    const base = defaults.baseURL.replace(TRAILING_SLASHES, \"\");\n    const path = resource.replace(LEADING_SLASHES, \"\");\n    url = base ? `${base}/${path}` : resource;\n  }\n\n  const response = 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  // For json with schema, validate\n  if (schema) {\n    const raw = await response.json();\n    return standardValidate(schema, raw, throwOnValidationError);\n  }\n\n  // No validation, return raw response data\n  return response;\n}\n\n/**\n * Creates an HTTP method helper bound to a fetch function\n */\nexport function createMethod<TFetch extends typeof $fetch>(\n  fetchFn: TFetch,\n  method: string\n) {\n  return <TSchema extends StandardSchemaV1>(\n    resource: string,\n    schema: TSchema,\n    options?: Omit<ExtendedRequestInit, \"method\">\n  ) => fetchFn(resource, schema, { ...options, method });\n}\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { GLOBAL_DEFAULTS } from \"./internal/constants\";\nimport { createMethod, fetchInternal } from \"./internal/utils\";\nimport type {\n  CreateFetchOptions,\n  ExtendedRequestInit,\n  FetchDefaults,\n} from \"./types\";\nimport { isStandardSchema } from \"./validator\";\n\n/**\n * Type-safe fetch wrapper with Standard Schema validation.\n *\n * - When `throwOnValidationError: true`: validated data of type `TSchema`\n * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`\n * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses\n *\n * If no schema is provided, returns the raw `Response` object.\n *\n * @throws {FetchError} When `throwOnFetchError: true` and response is not ok\n * @throws {ValidationError} When `throwOnValidationError: true` and validation fails\n *\n * @example\n * import { z } from \"zod\";\n * import { $fetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Basic usage (schema validation)\n * const user = await $fetch(\"/api/users/1\", UserSchema, { headers: { \"Authorization\": \"Bearer token\" } });\n * console.log(\"Validated user:\", user);\n *\n * // Raw usage (no schema validation and typed Response object)\n * const result = await $fetch(\"/api/data\", { method: \"POST\", body: JSON.stringify({ key: \"value\" }) });\n * const json = await result.json() as ResultType;\n * console.log(\"Raw response data:\", json);\n *\n * // Usage with validation errors returned instead of thrown\n * const result = await $fetch(\"/api/users/1\", UserSchema, { throwOnValidationError: false });\n *\n * if (result.issues) {\n *   console.error(\"Validation errors:\", result.issues);\n * } else {\n *   console.log(\"Validated user:\", result.value);\n * }\n */\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  resource: string,\n  schema: TSchema,\n  options?: ExtendedRequestInit\n): Promise<\n  | StandardSchemaV1.InferOutput<TSchema>\n  | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>\n>;\n\nexport async function $fetch(\n  resource: string,\n  options?: ExtendedRequestInit\n): Promise<Response>;\n\nexport async function $fetch(\n  resource: string,\n  schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n  optionsOrUndefined?: ExtendedRequestInit\n): Promise<unknown> {\n  const [schema, options] = isStandardSchema(schemaOrOptions)\n    ? [schemaOrOptions, optionsOrUndefined]\n    : [undefined, schemaOrOptions];\n\n  return await fetchInternal(resource, schema, options, GLOBAL_DEFAULTS);\n}\n\n/**\n * Convenience methods for common HTTP verbs.\n *\n * These methods always require a schema for validation.\n * For raw responses without validation, use `$fetch` directly.\n *\n * @example\n * import { z } from \"zod\";\n * import { api } from \"@zap-studio/fetch\";\n *\n * const PostSchema = z.object({\n *   id: z.number(),\n *   title: z.string(),\n *   content: z.string(),\n * });\n *\n * async function fetchPost(postId: number) {\n *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);\n *   return post; // post is typed as { id: number; title: string; content: string; }\n * }\n */\nexport const api = {\n  get: createMethod($fetch, \"GET\"),\n  post: createMethod($fetch, \"POST\"),\n  put: createMethod($fetch, \"PUT\"),\n  patch: createMethod($fetch, \"PATCH\"),\n  delete: createMethod($fetch, \"DELETE\"),\n};\n\n/**\n * Creates a custom fetch instance with pre-configured defaults.\n *\n * Use this factory to create API clients with a base URL, default headers,\n * and other shared configuration. Each instance is independent.\n *\n * @example\n * import { z } from \"zod\";\n * import { createFetch } from \"@zap-studio/fetch\";\n *\n * // Create a configured instance\n * const { $fetch, api } = createFetch({\n *   baseURL: \"https://api.example.com\",\n *   headers: { \"Authorization\": \"Bearer token\" },\n * });\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Now use relative paths - baseURL is prepended automatically\n * const user = await api.get(\"/users/1\", UserSchema);\n *\n * // Or use $fetch directly\n * const response = await $fetch(\"/users\", UserSchema, { method: \"POST\", body: { name: \"John\" } });\n */\nexport function createFetch(factoryOptions: CreateFetchOptions = {}): {\n  $fetch: typeof $fetch;\n  api: typeof api;\n} {\n  const defaults: FetchDefaults = {\n    baseURL: factoryOptions.baseURL ?? \"\",\n    headers: factoryOptions.headers,\n    throwOnFetchError: factoryOptions.throwOnFetchError ?? true,\n    throwOnValidationError: factoryOptions.throwOnValidationError ?? true,\n  };\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    resource: string,\n    schema: TSchema,\n    options?: ExtendedRequestInit\n  ): Promise<\n    | StandardSchemaV1.InferOutput<TSchema>\n    | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>\n  >;\n\n  async function customFetch(\n    resource: string,\n    options?: ExtendedRequestInit\n  ): Promise<Response>;\n\n  async function customFetch(\n    resource: string,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit\n  ): Promise<unknown> {\n    const [schema, options] = isStandardSchema(schemaOrOptions)\n      ? [schemaOrOptions, optionsOrUndefined]\n      : [undefined, schemaOrOptions];\n\n    return await fetchInternal(resource, schema, options, defaults);\n  }\n\n  const customApi = {\n    get: createMethod(customFetch, \"GET\"),\n    post: createMethod(customFetch, \"POST\"),\n    put: createMethod(customFetch, \"PUT\"),\n    patch: createMethod(customFetch, \"PATCH\"),\n    delete: createMethod(customFetch, \"DELETE\"),\n  };\n\n  return {\n    $fetch: customFetch,\n    api: customApi,\n  };\n}\n"],"mappings":";;;;;;;AAKA,MAAa,kBAAkB;CAC7B,SAAS;CACT,SAAS;CACT,mBAAmB;CACnB,wBAAwB;CACzB;;;;;;;;;;;;;;;;;;;;ACYD,SAAgB,aACd,MACA,UACqB;AACrB,KAAI,EAAE,QAAQ,UACZ;CAGF,MAAM,SAAS,IAAI,QAAQ,KAAK;AAChC,KAAI,UAAU;EACZ,MAAM,kBAAkB,IAAI,QAAQ,SAAS;AAC7C,OAAK,MAAM,CAAC,KAAK,UAAU,gBAAgB,SAAS,CAClD,QAAO,IAAI,KAAK,MAAM;;AAG1B,QAAO;;AAGT,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;;;;AAK7B,SAAS,cAAc,KAAsB;AAC3C,QAAO,qBAAqB,KAAK,IAAI;;;;;AAMvC,eAAsB,cACpB,UACA,QACA,SACA,UACkB;CAClB,MAAM,EACJ,yBAAyB,SAAS,wBAClC,oBAAoB,SAAS,mBAC7B,SAAS,gBACT,GAAG,SACD,WAAW,EAAE;CAEjB,MAAM,gBAAgB,aAAa,SAAS,SAAS,eAAe;CACpE,MAAM,OAAO;EAAE,GAAG;EAAM,SAAS;EAAe;AAGhD,KAAI,UAAU,KAAK,MAAM;AACvB,OAAK,OAAO,KAAK,UAAU,KAAK,KAAK;EAErC,MAAM,kBAAkB,IAAI,QAAQ,KAAK,QAAQ;AACjD,MAAI,CAAC,gBAAgB,IAAI,eAAe,CACtC,iBAAgB,IAAI,gBAAgB,mBAAmB;AAGzD,OAAK,UAAU;;CAIjB,IAAIA;AACJ,KAAI,cAAc,SAAS,CACzB,OAAM;MACD;EAEL,MAAM,OAAO,SAAS,QAAQ,QAAQ,kBAAkB,GAAG;EAC3D,MAAM,OAAO,SAAS,QAAQ,iBAAiB,GAAG;AAClD,QAAM,OAAO,GAAG,KAAK,GAAG,SAAS;;CAGnC,MAAM,WAAW,MAAM,MAAM,KAAK,KAAK;AAEvC,KAAI,qBAAqB,CAAC,SAAS,GACjC,OAAM,IAAI,WACR,QAAQ,SAAS,OAAO,IAAI,SAAS,cACrC,SACD;AAIH,KAAI,OAEF,QAAO,iBAAiB,QADZ,MAAM,SAAS,MAAM,EACI,uBAAuB;AAI9D,QAAO;;;;;AAMT,SAAgB,aACd,SACA,QACA;AACA,SACE,UACA,QACA,YACG,QAAQ,UAAU,QAAQ;EAAE,GAAG;EAAS;EAAQ,CAAC;;;;;AC/DxD,eAAsB,OACpB,UACA,iBACA,oBACkB;CAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,gBAAgB,GACvD,CAAC,iBAAiB,mBAAmB,GACrC,CAAC,QAAW,gBAAgB;AAEhC,QAAO,MAAM,cAAc,UAAU,QAAQ,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;AAwBxE,MAAa,MAAM;CACjB,KAAK,aAAa,QAAQ,MAAM;CAChC,MAAM,aAAa,QAAQ,OAAO;CAClC,KAAK,aAAa,QAAQ,MAAM;CAChC,OAAO,aAAa,QAAQ,QAAQ;CACpC,QAAQ,aAAa,QAAQ,SAAS;CACvC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BD,SAAgB,YAAY,iBAAqC,EAAE,EAGjE;CACA,MAAMC,WAA0B;EAC9B,SAAS,eAAe,WAAW;EACnC,SAAS,eAAe;EACxB,mBAAmB,eAAe,qBAAqB;EACvD,wBAAwB,eAAe,0BAA0B;EAClE;CAgBD,eAAe,YACb,UACA,iBACA,oBACkB;EAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,gBAAgB,GACvD,CAAC,iBAAiB,mBAAmB,GACrC,CAAC,QAAW,gBAAgB;AAEhC,SAAO,MAAM,cAAc,UAAU,QAAQ,SAAS,SAAS;;AAWjE,QAAO;EACL,QAAQ;EACR,KAVgB;GAChB,KAAK,aAAa,aAAa,MAAM;GACrC,MAAM,aAAa,aAAa,OAAO;GACvC,KAAK,aAAa,aAAa,MAAM;GACrC,OAAO,aAAa,aAAa,QAAQ;GACzC,QAAQ,aAAa,aAAa,SAAS;GAC5C;EAKA"}

package/dist/types-C0Uhh2KM.d.mts

@@ -0,0 +1,52 @@
+//#region src/types.d.ts
+/**
+ * Extended RequestInit type to include custom fetch options
+ */
+type ExtendedRequestInit = Omit<RequestInit, "body"> & {
+  /**
+   * Request body - can be a BodyInit value or an object that will be JSON-stringified
+   */
+  body?: BodyInit | Record<string, unknown>;
+  /**
+   * 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
+   */
+  throwOnValidationError?: boolean;
+};
+/**
+ * Internal defaults used by fetchInternal
+ */
+type FetchDefaults = {
+  /**
+   * Base URL to prepend to all requests
+   * @default ""
+   */
+  baseURL: string;
+  /**
+   * Default headers to include in all requests
+   * @default undefined
+   */
+  headers: HeadersInit | undefined;
+  /**
+   * 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
+   */
+  throwOnValidationError: boolean;
+};
+/**
+ * Options for creating a custom fetch instance with `createFetch`
+ */
+type CreateFetchOptions = Partial<FetchDefaults>;
+//#endregion
+export { ExtendedRequestInit as n, FetchDefaults as r, CreateFetchOptions as t };
+//# sourceMappingURL=types-C0Uhh2KM.d.mts.map

package/dist/types-C0Uhh2KM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-C0Uhh2KM.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAGA;;AAAkC,KAAtB,mBAAA,GAAsB,IAAA,CAAK,WAAL,EAAA,MAAA,CAAA,GAAA;EAIzB;;;EAgBG,IAAA,CAAA,EAhBH,QAgBG,GAhBQ,MAgBK,CAAA,MAUd,EAAA,OAAW,CAAA;EAgBV;;;;;;;;;;;;;;KA1BA,aAAA;;;;;;;;;;WAUD;;;;;;;;;;;;;;;KAgBC,kBAAA,GAAqB,QAAQ"}

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { n as ExtendedRequestInit, r as FetchDefaults, t as CreateFetchOptions } from "./types-C0Uhh2KM.mjs";
+export { CreateFetchOptions, ExtendedRequestInit, FetchDefaults };

package/dist/validator-BGjWrM4d.mjs

@@ -0,0 +1,44 @@
+import { n as ValidationError } from "./errors-DKxnbFHZ.mjs";
+
+//#region src/validator.ts
+/**
+* Type guard to check if a value is a Standard Schema schema
+*/
+function isStandardSchema(value) {
+	return !!value && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+}
+/**
+* Helper function to validate data using Standard Schema
+*
+* @throws {ValidationError} When `throwOnError` is true and validation fails
+*
+* @example
+* import { standardValidate } from "@zap-studio/fetch/validator";
+* import { z } from "zod";
+*
+* const UserSchema = z.object({ id: z.number(), name: z.string() });
+*
+* // Basic usage
+* const user = await standardValidate(UserSchema, data);
+*
+* // Non-throwing usage
+* const result = await standardValidate(UserSchema, data, false);
+* if (result.issues) {
+*   console.error("Validation failed:", result.issues);
+* } else {
+*   console.log("Success:", result.value);
+* }
+*/
+async function standardValidate(schema, input, throwOnError) {
+	let result = schema["~standard"].validate(input);
+	if (result instanceof Promise) result = await result;
+	if (result.issues) {
+		if (throwOnError) throw new ValidationError([...result.issues]);
+		return result;
+	}
+	return throwOnError ? result.value : result;
+}
+
+//#endregion
+export { standardValidate as n, isStandardSchema as t };
+//# sourceMappingURL=validator-BGjWrM4d.mjs.map

package/dist/validator-BGjWrM4d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator-BGjWrM4d.mjs","names":[],"sources":["../src/validator.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { ValidationError } from \"./errors\";\n\n/**\n * Type guard to check if a value is a Standard Schema schema\n */\nexport function isStandardSchema(value: unknown): value is StandardSchemaV1 {\n  return (\n    !!value &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    \"~standard\" in value\n  );\n}\n\n/**\n * Helper function to validate data using Standard Schema\n *\n * @throws {ValidationError} When `throwOnError` is true and validation fails\n *\n * @example\n * import { standardValidate } from \"@zap-studio/fetch/validator\";\n * import { z } from \"zod\";\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Basic usage\n * const user = await standardValidate(UserSchema, data);\n *\n * // Non-throwing usage\n * const result = await standardValidate(UserSchema, data, false);\n * if (result.issues) {\n *   console.error(\"Validation failed:\", result.issues);\n * } else {\n *   console.log(\"Success:\", result.value);\n * }\n */\nexport async function standardValidate<TSchema extends StandardSchemaV1>(\n  schema: TSchema,\n  input: unknown,\n  throwOnError: boolean\n): Promise<\n  | StandardSchemaV1.InferOutput<TSchema>\n  | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>\n> {\n  let result = schema[\"~standard\"].validate(input);\n  if (result instanceof Promise) {\n    result = await result;\n  }\n\n  if (result.issues) {\n    if (throwOnError) {\n      throw new ValidationError([...result.issues]);\n    }\n    return result;\n  }\n\n  return throwOnError ? result.value : result;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,iBAAiB,OAA2C;AAC1E,QACE,CAAC,CAAC,UACD,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;AA0BnB,eAAsB,iBACpB,QACA,OACA,cAIA;CACA,IAAI,SAAS,OAAO,aAAa,SAAS,MAAM;AAChD,KAAI,kBAAkB,QACpB,UAAS,MAAM;AAGjB,KAAI,OAAO,QAAQ;AACjB,MAAI,aACF,OAAM,IAAI,gBAAgB,CAAC,GAAG,OAAO,OAAO,CAAC;AAE/C,SAAO;;AAGT,QAAO,eAAe,OAAO,QAAQ"}

package/dist/validator.d.mts

@@ -0,0 +1,34 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/validator.d.ts
+
+/**
+ * Type guard to check if a value is a Standard Schema schema
+ */
+declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+/**
+ * Helper function to validate data using Standard Schema
+ *
+ * @throws {ValidationError} When `throwOnError` is true and validation fails
+ *
+ * @example
+ * import { standardValidate } from "@zap-studio/fetch/validator";
+ * import { z } from "zod";
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Basic usage
+ * const user = await standardValidate(UserSchema, data);
+ *
+ * // Non-throwing usage
+ * const result = await standardValidate(UserSchema, data, false);
+ * if (result.issues) {
+ *   console.error("Validation failed:", result.issues);
+ * } else {
+ *   console.log("Success:", result.value);
+ * }
+ */
+declare function standardValidate<TSchema extends StandardSchemaV1>(schema: TSchema, input: unknown, throwOnError: boolean): Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+//#endregion
+export { isStandardSchema, standardValidate };
+//# sourceMappingURL=validator.d.mts.map

package/dist/validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.mts","names":[],"sources":["../src/validator.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;AA8BsB,iBA9BN,gBAAA,CA8BsB,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IA9BqB,gBA8BrB;;;;;;;;;;;;;;;;;;;;;;;iBAAhB,iCAAiC,0BAC7C,iDAGP,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY"}

package/dist/validator.mjs

@@ -0,0 +1,4 @@
+import "./errors-DKxnbFHZ.mjs";
+import { n as standardValidate, t as isStandardSchema } from "./validator-BGjWrM4d.mjs";
+
+export { isStandardSchema, standardValidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "private": false,
   "publishConfig": {
@@ -12,27 +12,32 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "zod": "^4.1.12"
+    "@standard-schema/spec": "^1.0.0"
   },
   "devDependencies": {
-    "@types/node": "latest",
-    "jsdom": "latest",
-    "tsdown": "latest",
-    "typescript": "latest",
-    "vitest": "latest",
-    "@zap-studio/tsdown-config": "0.0.0",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.14",
+    "arktype": "^2.1.27",
+    "jsdom": "^27.2.0",
+    "tsdown": "^0.17.0-beta.4",
+    "typescript": "^5.9.3",
+    "valibot": "^1.2.0",
+    "vitest": "^4.0.14",
+    "zod": "^4.1.13",
     "@zap-studio/vitest-config": "0.0.0",
+    "@zap-studio/tsdown-config": "0.0.0",
     "@zap-studio/typescript-config": "0.0.0"
   },
   "exports": {
-    ".": "./dist/index.js",
-    "./errors": "./dist/errors/index.js",
-    "./types": "./dist/types/index.js",
+    ".": "./dist/index.mjs",
+    "./errors": "./dist/errors.mjs",
+    "./types": "./dist/types.mjs",
+    "./validator": "./dist/validator.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "scripts": {
     "build": "tsdown --config tsdown.config.ts",
     "check-types": "tsc --noEmit",

package/dist/errors/index.d.ts

@@ -1,10 +0,0 @@
-//#region src/errors/index.d.ts
-declare class FetchError extends Error {
-  status: number;
-  statusText: string;
-  response: Response;
-  constructor(message: string, status: number, statusText: string, response: Response);
-}
-//#endregion
-export { FetchError };
-//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/errors/index.ts"],"sourcesContent":[],"mappings":";cAAa,UAAA,SAAmB,KAAA;EAAnB,MAAA,EAAA,MAAW;EAKL,UAAA,EAAA,MAAA;EAAA,QAAA,EAAA,QAAA;EALa,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,QAAA,EAKb,QALa"}

package/dist/errors/index.js

@@ -1,3 +0,0 @@
-import { t as FetchError } from "../errors-DrfSty0J.js";
-
-export { FetchError };

package/dist/errors-DrfSty0J.js

@@ -1,14 +0,0 @@
-//#region src/errors/index.ts
-var FetchError = class extends Error {
-	constructor(message, status, statusText, response) {
-		super(message);
-		this.status = status;
-		this.statusText = statusText;
-		this.response = response;
-		this.name = "FetchError";
-	}
-};
-
-//#endregion
-export { FetchError as t };
-//# sourceMappingURL=errors-DrfSty0J.js.map

package/dist/errors-DrfSty0J.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-DrfSty0J.js","names":["status: number","statusText: string","response: Response"],"sources":["../src/errors/index.ts"],"sourcesContent":["export class FetchError extends Error {\n\tconstructor(\n\t\tmessage: string,\n\t\tpublic status: number,\n\t\tpublic statusText: string,\n\t\tpublic response: Response,\n\t) {\n\t\tsuper(message);\n\t\tthis.name = \"FetchError\";\n\t}\n}\n"],"mappings":";AAAA,IAAa,aAAb,cAAgC,MAAM;CACrC,YACC,SACA,AAAOA,QACP,AAAOC,YACP,AAAOC,UACN;AACD,QAAM,QAAQ;EAJP;EACA;EACA;AAGP,OAAK,OAAO"}

package/dist/index-BkzLFXkF.d.ts

@@ -1,9 +0,0 @@
-//#region src/types/index.d.ts
-type FetchConfig<TBody> = Omit<RequestInit, "body"> & {
-  body?: TBody;
-  throwOnValidationError?: boolean;
-};
-type ResponseType = "json" | "text" | "blob" | "arrayBuffer" | "formData";
-//#endregion
-export { ResponseType as n, FetchConfig as t };
-//# sourceMappingURL=index-BkzLFXkF.d.ts.map

package/dist/index-BkzLFXkF.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BkzLFXkF.d.ts","names":[],"sources":["../src/types/index.ts"],"sourcesContent":[],"mappings":";KAAY,qBAAqB,KAAK;EAA1B,IAAA,CAAA,EACJ,KADI;EAA0B,sBAAA,CAAA,EAAA,OAAA;CAAL;AACzB,KAII,YAAA,GAJJ,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,aAAA,GAAA,UAAA"}

package/dist/index.d.ts

@@ -1,63 +0,0 @@
-import { n as ResponseType, t as FetchConfig } from "./index-BkzLFXkF.js";
-import { z } from "zod";
-
-//#region src/index.d.ts
-
-/**
- * Type-safe fetch wrapper with Zod validation
- *
- * @example
- * import { z } from "zod";
- * import { safeFetch } from "@zap-studio/fetch";
- *
- * const UserSchema = z.object({
- *   id: z.number(),
- *   name: z.string(),
- *   email: z.string().email(),
- * });
- *
- * async function getUser(userId: number) {
- *   const user = await safeFetch(
- *     `https://api.example.com/users/${userId}`,
- *     UserSchema,
- *     { method: "GET" }
- *   );
- *   return user; // user is typed as { id: number; name: string; email: string; }
- * }
- */
-declare function safeFetch<TResponse$1, TBody$1 = unknown>(url: string, responseSchema: z.ZodType<TResponse$1>, config?: FetchConfig<TBody$1> & {
-  throwOnValidationError?: true;
-  responseType?: ResponseType;
-}): Promise<TResponse$1>;
-declare function safeFetch<TResponse$1, TBody$1 = unknown>(url: string, responseSchema: z.ZodType<TResponse$1>, config?: FetchConfig<TBody$1> & {
-  throwOnValidationError: false;
-  responseType?: ResponseType;
-}): Promise<ReturnType<typeof responseSchema.safeParse>>;
-/**
- * Convenience methods for common HTTP verbs
- *
- * @example
- * import { z } from "zod";
- * import { api } from "@zap-studio/fetch";
- *
- * const PostSchema = z.object({
- *   id: z.number(),
- *   title: z.string(),
- *   content: z.string(),
- * });
- *
- * async function fetchPost(postId: number) {
- *  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
- *   return post; // post is typed as { id: number; title: string; content: string; }
- * }
- */
-declare const api: {
-  get: <TResponse>(url: string, schema: z.ZodType<TResponse>, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
-  post: <TResponse, TBody = unknown>(url: string, schema: z.ZodType<TResponse>, body?: TBody, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
-  put: <TResponse, TBody = unknown>(url: string, schema: z.ZodType<TResponse>, body?: TBody, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
-  patch: <TResponse, TBody = unknown>(url: string, schema: z.ZodType<TResponse>, body?: TBody, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
-  delete: <TResponse>(url: string, schema: z.ZodType<TResponse>, config?: Omit<RequestInit, "method" | "body">) => Promise<TResponse>;
-};
-//#endregion
-export { api, safeFetch };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;;;;;AASA;;;;;;;;;;AAoHA;AAGoB,iBAhIE,SAgIF,CAAA,WAAA,EAAA,UAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,cAAA,EA9HH,CAAA,CAAE,OA8HC,CA9HO,WA8HP,CAAA,EAAA,MACT,CADS,EA7HV,WA6HU,CA7HE,OA6HF,CAAA,GAAA;EAAR,sBAAA,CAAA,EAAA,IAAA;EACI,YAAA,CAAA,EA5HC,YA4HD;CAAL,CAAA,EA1HR,OA0HQ,CA1HA,WA0HA,CAAA;AAAoC,iBAxHzB,SAwHyB,CAAA,WAAA,EAAA,UAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,cAAA,EAtH9B,CAAA,CAAE,OAsH4B,CAtHpB,WAsHoB,CAAA,EAAA,MAKrC,CALqC,EArHrC,WAqHqC,CArHzB,OAqHyB,CAAA,GAAA;EAAA,sBAAA,EAAA,KAAA;EAK3B,YAAA,CAAA,EAxHH,YAwHG;CAAV,CAAA,EAtHP,OAsHS,CAtHD,UAsHC,CAAA,OAtHiB,cAAA,CAAe,SAsHhC,CAAA,CAAA;;;;;;;;;;;;;;;;;;;AAgBmC,cAzBlC,GAyBkC,EAAA;EAK3B,GAAA,EAAA,CAAA,SAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EA3BV,CAAA,CAAE,OA2BQ,CA3BA,SA2BA,CAAA,EAAA,MAAA,CAAA,EA1BT,IA0BS,CA1BJ,WA0BI,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GA1B2B,OA0B3B,CA1B2B,SA0B3B,CAAA;EAAR,IAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EArBF,CAAA,CAAE,OAqBA,CArBQ,SAqBR,CAAA,EAAA,IAAA,CAAA,EApBH,KAoBG,EAAA,MAAA,CAAA,EAnBD,IAmBC,CAnBI,WAmBJ,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAnBmC,OAmBnC,CAnBmC,SAmBnC,CAAA;EACI,GAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EAfN,CAAA,CAAE,OAeI,CAfI,SAeJ,CAAA,EAAA,IAAA,CAAA,EAdP,KAcO,EAAA,MAAA,CAAA,EAbL,IAaK,CAbA,WAaA,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAb+B,OAa/B,CAb+B,SAa/B,CAAA;EAAL,KAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EARD,CAAA,CAAE,OAQD,CARS,SAQT,CAAA,EAAA,IAAA,CAAA,EAPF,KAOE,EAAA,MAAA,CAAA,EANA,IAMA,CANK,WAML,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GANoC,OAMpC,CANoC,SAMpC,CAAA;EAAoC,MAAA,EAAA,CAAA,SAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,MAAA,EADrC,CAAA,CAAE,OACmC,CAD3B,SAC2B,CAAA,EAAA,MAAA,CAAA,EAApC,IAAoC,CAA/B,WAA+B,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAAA,OAAA,CAAA,SAAA,CAAA;CAAA"}

package/dist/index.js

@@ -1,79 +0,0 @@
-import { t as FetchError } from "./errors-DrfSty0J.js";
-
-//#region src/index.ts
-async function safeFetch(url, responseSchema, config) {
-	const { body, headers, throwOnValidationError = true, responseType = "json",...rest } = config || {};
-	const fetchConfig = {
-		...rest,
-		headers: { ...headers }
-	};
-	if (body !== void 0) {
-		const shouldSetContentType = !headers || typeof headers === "object" && !Array.isArray(headers) && !(headers instanceof Headers) && !("Content-Type" in headers);
-		if (body instanceof FormData) fetchConfig.body = body;
-		else if (typeof body === "string") {
-			fetchConfig.body = body;
-			if (shouldSetContentType) fetchConfig.headers["Content-Type"] = "text/plain";
-		} else {
-			fetchConfig.body = JSON.stringify(body);
-			if (shouldSetContentType) fetchConfig.headers["Content-Type"] = "application/json";
-		}
-	}
-	const response = await fetch(url, fetchConfig);
-	if (!response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response.status, response.statusText, response);
-	let data;
-	if (responseType === "json") if (response.headers.get("content-type")?.includes("application/json")) data = await response.json();
-	else throw new FetchError("Expected JSON response but received different content type", response.status, response.statusText, response);
-	else if (responseType === "text") data = await response.text();
-	else if (responseType === "blob") data = await response.blob();
-	else if (responseType === "arrayBuffer") data = await response.arrayBuffer();
-	else if (responseType === "formData") data = await response.formData();
-	if (throwOnValidationError) return responseSchema.parse(data);
-	return responseSchema.safeParse(data);
-}
-/**
-* Convenience methods for common HTTP verbs
-*
-* @example
-* import { z } from "zod";
-* import { api } from "@zap-studio/fetch";
-*
-* const PostSchema = z.object({
-*   id: z.number(),
-*   title: z.string(),
-*   content: z.string(),
-* });
-*
-* async function fetchPost(postId: number) {
-*  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
-*   return post; // post is typed as { id: number; title: string; content: string; }
-* }
-*/
-const api = {
-	get: (url, schema, config) => safeFetch(url, schema, {
-		...config,
-		method: "GET"
-	}),
-	post: (url, schema, body, config) => safeFetch(url, schema, {
-		...config,
-		method: "POST",
-		body
-	}),
-	put: (url, schema, body, config) => safeFetch(url, schema, {
-		...config,
-		method: "PUT",
-		body
-	}),
-	patch: (url, schema, body, config) => safeFetch(url, schema, {
-		...config,
-		method: "PATCH",
-		body
-	}),
-	delete: (url, schema, config) => safeFetch(url, schema, {
-		...config,
-		method: "DELETE"
-	})
-};
-
-//#endregion
-export { api, safeFetch };
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["fetchConfig: RequestInit","data: unknown"],"sources":["../src/index.ts"],"sourcesContent":["import type { z } from \"zod\";\nimport { FetchError } from \"./errors\";\nimport type { FetchConfig, ResponseType } from \"./types\";\n\n/**\n * Type-safe fetch wrapper with Zod validation\n *\n * @example\n * import { z } from \"zod\";\n * import { safeFetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({\n *   id: z.number(),\n *   name: z.string(),\n *   email: z.string().email(),\n * });\n *\n * async function getUser(userId: number) {\n *   const user = await safeFetch(\n *     `https://api.example.com/users/${userId}`,\n *     UserSchema,\n *     { method: \"GET\" }\n *   );\n *   return user; // user is typed as { id: number; name: string; email: string; }\n * }\n */\nexport async function safeFetch<TResponse, TBody = unknown>(\n\turl: string,\n\tresponseSchema: z.ZodType<TResponse>,\n\tconfig?: FetchConfig<TBody> & {\n\t\tthrowOnValidationError?: true;\n\t\tresponseType?: ResponseType;\n\t},\n): Promise<TResponse>;\n\nexport async function safeFetch<TResponse, TBody = unknown>(\n\turl: string,\n\tresponseSchema: z.ZodType<TResponse>,\n\tconfig?: FetchConfig<TBody> & {\n\t\tthrowOnValidationError: false;\n\t\tresponseType?: ResponseType;\n\t},\n): Promise<ReturnType<typeof responseSchema.safeParse>>;\n\nexport async function safeFetch<TResponse, TBody = unknown>(\n\turl: string,\n\tresponseSchema: z.ZodType<TResponse>,\n\tconfig?: FetchConfig<TBody> & { responseType?: ResponseType },\n): Promise<TResponse | ReturnType<typeof responseSchema.safeParse>> {\n\tconst {\n\t\tbody,\n\t\theaders,\n\t\tthrowOnValidationError = true,\n\t\tresponseType = \"json\",\n\t\t...rest\n\t} = config || {};\n\n\tconst fetchConfig: RequestInit = {\n\t\t...rest,\n\t\theaders: {\n\t\t\t...(headers as Record<string, string>),\n\t\t},\n\t};\n\n\t// Only set Content-Type if body exists and it's not FormData\n\tif (body !== undefined) {\n\t\tconst shouldSetContentType =\n\t\t\t!headers ||\n\t\t\t(typeof headers === \"object\" &&\n\t\t\t\t!Array.isArray(headers) &&\n\t\t\t\t!(headers instanceof Headers) &&\n\t\t\t\t!(\"Content-Type\" in headers));\n\n\t\tif (body instanceof FormData) {\n\t\t\tfetchConfig.body = body;\n\t\t} else if (typeof body === \"string\") {\n\t\t\tfetchConfig.body = body;\n\t\t\tif (shouldSetContentType) {\n\t\t\t\t(fetchConfig.headers as Record<string, string>)[\"Content-Type\"] =\n\t\t\t\t\t\"text/plain\";\n\t\t\t}\n\t\t} else {\n\t\t\tfetchConfig.body = JSON.stringify(body);\n\t\t\tif (shouldSetContentType) {\n\t\t\t\t(fetchConfig.headers as Record<string, string>)[\"Content-Type\"] =\n\t\t\t\t\t\"application/json\";\n\t\t\t}\n\t\t}\n\t}\n\n\tconst response = await fetch(url, fetchConfig);\n\n\tif (!response.ok) {\n\t\tthrow new FetchError(\n\t\t\t`HTTP ${response.status}: ${response.statusText}`,\n\t\t\tresponse.status,\n\t\t\tresponse.statusText,\n\t\t\tresponse,\n\t\t);\n\t}\n\n\t// Parse response based on responseType\n\tlet data: unknown;\n\n\tif (responseType === \"json\") {\n\t\tconst contentType = response.headers.get(\"content-type\");\n\t\tif (contentType?.includes(\"application/json\")) {\n\t\t\tdata = await response.json();\n\t\t} else {\n\t\t\tthrow new FetchError(\n\t\t\t\t\"Expected JSON response but received different content type\",\n\t\t\t\tresponse.status,\n\t\t\t\tresponse.statusText,\n\t\t\t\tresponse,\n\t\t\t);\n\t\t}\n\t} else if (responseType === \"text\") {\n\t\tdata = await response.text();\n\t} else if (responseType === \"blob\") {\n\t\tdata = await response.blob();\n\t} else if (responseType === \"arrayBuffer\") {\n\t\tdata = await response.arrayBuffer();\n\t} else if (responseType === \"formData\") {\n\t\tdata = await response.formData();\n\t}\n\n\tif (throwOnValidationError) {\n\t\treturn responseSchema.parse(data);\n\t}\n\n\treturn responseSchema.safeParse(data);\n}\n\n/**\n * Convenience methods for common HTTP verbs\n *\n * @example\n * import { z } from \"zod\";\n * import { api } from \"@zap-studio/fetch\";\n *\n * const PostSchema = z.object({\n *   id: z.number(),\n *   title: z.string(),\n *   content: z.string(),\n * });\n *\n * async function fetchPost(postId: number) {\n *  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);\n *   return post; // post is typed as { id: number; title: string; content: string; }\n * }\n */\nexport const api = {\n\tget: <TResponse>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"GET\" }),\n\n\tpost: <TResponse, TBody = unknown>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tbody?: TBody,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"POST\", body }),\n\n\tput: <TResponse, TBody = unknown>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tbody?: TBody,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"PUT\", body }),\n\n\tpatch: <TResponse, TBody = unknown>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tbody?: TBody,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"PATCH\", body }),\n\n\tdelete: <TResponse>(\n\t\turl: string,\n\t\tschema: z.ZodType<TResponse>,\n\t\tconfig?: Omit<RequestInit, \"method\" | \"body\">,\n\t) => safeFetch(url, schema, { ...config, method: \"DELETE\" }),\n};\n"],"mappings":";;;AA4CA,eAAsB,UACrB,KACA,gBACA,QACmE;CACnE,MAAM,EACL,MACA,SACA,yBAAyB,MACzB,eAAe,OACf,GAAG,SACA,UAAU,EAAE;CAEhB,MAAMA,cAA2B;EAChC,GAAG;EACH,SAAS,EACR,GAAI,SACJ;EACD;AAGD,KAAI,SAAS,QAAW;EACvB,MAAM,uBACL,CAAC,WACA,OAAO,YAAY,YACnB,CAAC,MAAM,QAAQ,QAAQ,IACvB,EAAE,mBAAmB,YACrB,EAAE,kBAAkB;AAEtB,MAAI,gBAAgB,SACnB,aAAY,OAAO;WACT,OAAO,SAAS,UAAU;AACpC,eAAY,OAAO;AACnB,OAAI,qBACH,CAAC,YAAY,QAAmC,kBAC/C;SAEI;AACN,eAAY,OAAO,KAAK,UAAU,KAAK;AACvC,OAAI,qBACH,CAAC,YAAY,QAAmC,kBAC/C;;;CAKJ,MAAM,WAAW,MAAM,MAAM,KAAK,YAAY;AAE9C,KAAI,CAAC,SAAS,GACb,OAAM,IAAI,WACT,QAAQ,SAAS,OAAO,IAAI,SAAS,cACrC,SAAS,QACT,SAAS,YACT,SACA;CAIF,IAAIC;AAEJ,KAAI,iBAAiB,OAEpB,KADoB,SAAS,QAAQ,IAAI,eAAe,EACvC,SAAS,mBAAmB,CAC5C,QAAO,MAAM,SAAS,MAAM;KAE5B,OAAM,IAAI,WACT,8DACA,SAAS,QACT,SAAS,YACT,SACA;UAEQ,iBAAiB,OAC3B,QAAO,MAAM,SAAS,MAAM;UAClB,iBAAiB,OAC3B,QAAO,MAAM,SAAS,MAAM;UAClB,iBAAiB,cAC3B,QAAO,MAAM,SAAS,aAAa;UACzB,iBAAiB,WAC3B,QAAO,MAAM,SAAS,UAAU;AAGjC,KAAI,uBACH,QAAO,eAAe,MAAM,KAAK;AAGlC,QAAO,eAAe,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;AAqBtC,MAAa,MAAM;CAClB,MACC,KACA,QACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAO,CAAC;CAEzD,OACC,KACA,QACA,MACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAQ;EAAM,CAAC;CAEhE,MACC,KACA,QACA,MACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAO;EAAM,CAAC;CAE/D,QACC,KACA,QACA,MACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAS;EAAM,CAAC;CAEjE,SACC,KACA,QACA,WACI,UAAU,KAAK,QAAQ;EAAE,GAAG;EAAQ,QAAQ;EAAU,CAAC;CAC5D"}

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-import { n as ResponseType, t as FetchConfig } from "../index-BkzLFXkF.js";
-export { FetchConfig, ResponseType };