1000fetches 0.1.0 → 0.1.1

package/dist/index.cjs.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class e extends Error{name="HttpError";status;statusText;data;response;url;method;cause;constructor(e,t,r,s,a,o,n,i){super(`HTTP ${t} ${r}: ${e} (${n} ${o})`,{cause:i}),this.status=t,this.statusText=r,this.data=s,this.response=a,this.url=o,this.method=n}}class t extends Error{name="NetworkError";cause;constructor(e,t){super(e,{cause:t})}}class r extends Error{name="SchemaValidationError";schema;data;cause;constructor(e,t,r,s){super(e,{cause:s}),this.schema=t,this.data=r}}class s extends Error{name="TimeoutError";cause;constructor(e,t){super(e,{cause:t})}}class a extends Error{name="PathParameterError";url;requiredParams;providedParams;cause;constructor(e,t,r,s,a){super(e,{cause:a}),this.url=t,this.requiredParams=r,this.providedParams=s}}class o extends Error{name="InterceptorError";interceptorType;url;method;cause;constructor(e,t,r,s,a){super(e,{cause:a}),this.interceptorType=t,this.url=r,this.method=s}}class n extends Error{name="SerializationError";cause;constructor(e,t){super(e,{cause:t})}}function i(e){return null!==e&&("object"==typeof e||"function"==typeof e)&&"~standard"in e&&"object"==typeof e["~standard"]&&null!==e["~standard"]&&"validate"in e["~standard"]&&"function"==typeof e["~standard"].validate&&"version"in e["~standard"]&&"number"==typeof e["~standard"].version&&"vendor"in e["~standard"]&&"string"==typeof e["~standard"].vendor}function c(e){return{parse:t=>{const r=e["~standard"].validate(t);if(r instanceof Promise)throw new Error("Async Standard Schema validation is not supported");if("issues"in r&&r.issues){const e=Array.from(r.issues).map(e=>e.message).join("; ");throw new Error(`Standard Schema validation failed: ${e}`)}return r.value}}}function d(){return{validate(e,t){if(!i(e))throw new Error("Invalid schema: Schema must implement the Standard Schema interface");return c(e).parse(t)},isSchema:e=>i(e)}}function u(){return{validate(e,t){if(!i(e))throw new Error("Invalid schema: Schema must implement the Standard Schema interface");return d().validate(e,t)},isSchema:e=>i(e)}}function h(e,t={}){return e.replace(/:([a-zA-Z0-9_]+)/g,(r,s)=>{if(void 0===t[s])throw new a(`Missing required path parameter: ${s}`,e,[s],Object.keys(t));return String(t[s])})}const l={maxRetries:3,retryDelay:300,backoffFactor:2,retryStatusCodes:[429,500,502,503,504],retryNetworkErrors:!0,maxRetryDelay:3e4,shouldRetry:()=>!0};exports.HttpClient=class{baseUrl;defaultHeaders;defaultTimeout;schemaValidator;requestInterceptors;responseInterceptors;defaultRetryOptions;constructor(e={}){this.baseUrl=function(e){if(!e)return"";try{new URL(e)}catch{throw new Error(`Invalid baseUrl: "${e}". Must be a valid URL.`)}return e.endsWith("/")?e.slice(0,-1):e}(e.baseUrl),this.defaultHeaders=e.headers||{},this.defaultTimeout=e.timeout||3e4,this.schemaValidator=e.schemaValidator||u(),this.requestInterceptors=e.requestInterceptors||[],this.responseInterceptors=e.responseInterceptors||[],this.defaultRetryOptions=e.retryOptions}addRequestInterceptor(e){this.requestInterceptors.push(e)}addResponseInterceptor(e){this.responseInterceptors.push(e)}setSchemaValidator(e){this.schemaValidator=e}async shouldRetry(a,o,n){if(!1===n)return!1;const i=this.getRetryOptions(n);if(o>=i.maxRetries)return!1;if("function"==typeof i.shouldRetry)try{return await i.shouldRetry(a,o)}catch(c){console.warn("Custom shouldRetry function failed:",c)}return!!(a instanceof t&&i.retryNetworkErrors)||(!!(a instanceof e&&i.retryStatusCodes.includes(a.status))||!(a instanceof r)&&a instanceof s)}getRetryDelay(e,t){const r=t.retryDelay*Math.pow(t.backoffFactor,e),s=Math.min(r,t.maxRetryDelay),a=s+.2*s*(2*Math.random()-1);return Math.max(1,Math.floor(a))}getRetryOptions(e){return!1===e?{...l,maxRetries:0}:!0===e?{...l,...this.defaultRetryOptions}:"object"==typeof e?{...l,...this.defaultRetryOptions,...e}:{...l,...this.defaultRetryOptions}}sleep(e){return new Promise(t=>setTimeout(t,e))}async request(e,r,s={}){let a=0;for(;;)try{return await this.executeRequest(e,r,s)}catch(o){if(!(o instanceof Error))throw new t(String(o),void 0);if(await this.shouldRetry(o,a,s.retry)){const e=this.getRetryOptions(s.retry),t=this.getRetryDelay(a,e);await this.sleep(t),a++;continue}throw o}}async executeRequest(i,c,d={}){let u=this.resolveUrl(c,d.pathParams),h={url:u,method:i,params:d.params,headers:this.prepareHeaders(d.headers),body:d.body,fetchOptions:{credentials:d.credentials,cache:d.cache,mode:d.mode,redirect:d.redirect}};for(const e of this.requestInterceptors)try{h=await e(h)}catch(b){throw new o(`Request interceptor failed: ${b instanceof Error?b.message:String(b)}`,"request",u,i,b instanceof Error?b:void 0)}if(u=h.url,h.params&&Object.keys(h.params).length>0){const e=new URLSearchParams;for(const[r,s]of Object.entries(h.params))void 0!==s&&e.append(r,String(s));const t=e.toString();t&&(u+=(u.includes("?")?"&":"?")+t)}const l={method:h.method,headers:h.headers,...h.fetchOptions};if(void 0!==h.body&&("POST"===h.method||"PUT"===h.method||"PATCH"===h.method))if(h.body instanceof FormData||h.body instanceof Blob||h.body instanceof ArrayBuffer||h.body instanceof URLSearchParams||"string"==typeof h.body)l.body=h.body;else try{l.body=JSON.stringify(h.body)}catch(b){throw new n(`Failed to serialize request body: ${b instanceof Error?b.message:"Invalid data structure"}`,b instanceof Error?b:void 0)}const p=d.timeout||this.defaultTimeout,f=new AbortController,m=setTimeout(()=>f.abort(),p),y=h.signal||d.signal;let w;const E=y?(()=>{const e=this.mergeAbortSignals(y,f.signal);return w=e.cleanup,e.signal})():f.signal;try{const e=await fetch(u,{...l,signal:E});let t=await this.processResponse(e,d,i,u);return d.schema&&(t.data=this.validateResponseData(d.schema,t.data)),t}catch(b){if(b instanceof DOMException&&"AbortError"===b.name||b instanceof Error&&"AbortError"===b.name||b instanceof Error&&b.message.toLowerCase().includes("timeout"))throw new s(`Request timed out after ${p}ms`,b instanceof Error?b:void 0);if(b instanceof e||b instanceof r||b instanceof o||b instanceof a||b instanceof n)throw b;throw new t(b instanceof Error?b.message:String(b),b instanceof Error?b:void 0)}finally{clearTimeout(m),w?.()}}validateWithSchema(e,t,s){try{return this.schemaValidator.validate(e,t)}catch(a){throw new r(`${s}: ${a instanceof Error?a.message:"Unknown error"}`,e,t,a instanceof Error?a:void 0)}}validateResponseData(e,t){return this.validateWithSchema(e,t,"Response schema validation failed")}validateSchema(e,t){return this.validateWithSchema(e,t,"Schema validation failed")}prepareHeaders(e={}){const t=new Headers;for(const[r,s]of Object.entries(this.defaultHeaders))null!=s&&t.set(r,String(s));for(const[r,s]of Object.entries(e))null!=s&&t.set(r,String(s));return t}extractHeaders(e){const t={};return e.forEach((e,r)=>{t[r]=e}),t}createHttpError(t,r,s,a,o,n){return new e(`Request failed with status code ${t.status}`,t.status,o||t.statusText,r,t,s,a,n)}async parseResponseBody(e,t){const r=e.headers.get("content-type")??"";try{if("text"===t.responseType)return await e.text();if("blob"===t.responseType)return await e.blob();if("arrayBuffer"===t.responseType)return await e.arrayBuffer();if(r.includes("application/json")){const t=await e.text();return t?JSON.parse(t):null}return await e.text()}catch(s){if(204===e.status)return;if(r.includes("application/json")&&s instanceof SyntaxError)throw new Error(`Failed to parse JSON response: ${s.message}`);throw s}}async processResponse(e,t,r,s){const a=this.extractHeaders(e.headers),n=t.validateStatus||(e=>e>=200&&e<300),i=await this.parseResponseBody(e,t);if(!n(e.status))throw this.createHttpError(e,i,s,r);const c={data:i,status:e.status,statusText:e.statusText,headers:a,method:r,url:s,raw:e};let d=c;const u=c.status;for(const l of this.responseInterceptors)try{d=await l(d)}catch(h){throw new o(`Response interceptor failed: ${h instanceof Error?h.message:String(h)}`,"response",s,r,h instanceof Error?h:void 0)}if(d.status!==u&&!n(d.status))throw this.createHttpError(e,d.data,s,r,d.statusText);return d}mergeAbortSignals(e,t){if(e.aborted||t.aborted){const e=new AbortController;return e.abort(),{signal:e.signal}}const r=new AbortController,s=()=>{r.abort(),a()},a=()=>{e.removeEventListener("abort",s),t.removeEventListener("abort",s)};return e.addEventListener("abort",s),t.addEventListener("abort",s),{signal:r.signal,cleanup:a}}get(e,t){return this.request("GET",e,t||{})}post(e,t,r){return this.request("POST",e,{...r||{},body:t})}put(e,t,r){return this.request("PUT",e,{...r||{},body:t})}patch(e,t,r){return this.request("PATCH",e,{...r||{},body:t})}delete(e,t){return this.request("DELETE",e,t||{})}validatePathParams(e,t){if(!t){const t=this.extractRequiredPathParams(e);if(t.length>0)throw new a(`Missing required path parameters for URL "${e}": ${t.join(", ")}. Please provide pathParams: { ${t.map(e=>`${e}: value`).join(", ")} }`,e,t,[]);return}const r=this.extractRequiredPathParams(e),s=Object.keys(t),o=r.filter(e=>!s.includes(e));if(o.length>0)throw new a(`Missing required path parameters: ${o.join(", ")}. Provided: ${s.join(", ")}`,e,r,s)}extractRequiredPathParams(e){const t=e.match(/:([a-zA-Z0-9_]+)/g);return t?t.map(e=>e.slice(1)):[]}resolveUrl(e,t){this.validatePathParams(e,t);const r=t?h(e,t):e;if(/^https?:\/\//i.test(r))return r;const s=r.startsWith("/")?r.slice(1):r;return`${this.baseUrl}/${s}`}},exports.HttpError=e,exports.InterceptorError=o,exports.NetworkError=t,exports.PathParameterError=a,exports.SchemaValidationError=r,exports.TimeoutError=s,exports.createSchemaValidator=u,exports.createStandardSchemaValidator=d,exports.generatePath=h,exports.isStandardSchema=i,exports.standardSchemaAdapter=c;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class e extends Error{name="HttpError";status;statusText;data;response;url;method;cause;constructor(e,t,r,s,a,o,n,i){super(`HTTP ${t} ${r}: ${e} (${n} ${o})`,{cause:i}),this.status=t,this.statusText=r,this.data=s,this.response=a,this.url=o,this.method=n}}class t extends Error{name="NetworkError";cause;constructor(e,t){super(e,{cause:t})}}class r extends Error{name="SchemaValidationError";schema;data;cause;constructor(e,t,r,s){super(e,{cause:s}),this.schema=t,this.data=r}}class s extends Error{name="TimeoutError";cause;constructor(e,t){super(e,{cause:t})}}class a extends Error{name="PathParameterError";url;requiredParams;providedParams;cause;constructor(e,t,r,s,a){super(e,{cause:a}),this.url=t,this.requiredParams=r,this.providedParams=s}}class o extends Error{name="InterceptorError";interceptorType;url;method;cause;constructor(e,t,r,s,a){super(e,{cause:a}),this.interceptorType=t,this.url=r,this.method=s}}class n extends Error{name="SerializationError";cause;constructor(e,t){super(e,{cause:t})}}function i(e){return null!==e&&("object"==typeof e||"function"==typeof e)&&"~standard"in e&&"object"==typeof e["~standard"]&&null!==e["~standard"]&&"validate"in e["~standard"]&&"function"==typeof e["~standard"].validate&&"version"in e["~standard"]&&"number"==typeof e["~standard"].version&&"vendor"in e["~standard"]&&"string"==typeof e["~standard"].vendor}function c(e){return{parse:t=>{const r=e["~standard"].validate(t);if(r instanceof Promise)throw new Error("Async Standard Schema validation is not supported");if("issues"in r&&r.issues){const e=Array.from(r.issues).map(e=>e.message).join("; ");throw new Error(`Standard Schema validation failed: ${e}`)}return r.value}}}function d(){return{validate(e,t){if(!i(e))throw new Error("Invalid schema: Schema must implement the Standard Schema interface");return c(e).parse(t)},isSchema:e=>i(e)}}function u(){return{validate(e,t){if(!i(e))throw new Error("Invalid schema: Schema must implement the Standard Schema interface");return d().validate(e,t)},isSchema:e=>i(e)}}function h(e,t={}){return e.replace(/:([a-zA-Z0-9_]+)/g,(r,s)=>{if(void 0===t[s])throw new a(`Missing required path parameter: ${s}`,e,[s],Object.keys(t));return String(t[s])})}const l={maxRetries:3,retryDelay:300,backoffFactor:2,retryStatusCodes:[429,500,502,503,504],retryNetworkErrors:!0,maxRetryDelay:3e4,shouldRetry:()=>!0};exports.HttpClient=class{baseUrl;defaultHeaders;defaultTimeout;schemaValidator;requestInterceptors;responseInterceptors;defaultRetryOptions;constructor(e={}){this.baseUrl=function(e){if(!e)return"";try{new URL(e)}catch{throw new Error(`Invalid baseUrl: "${e}". Must be a valid URL.`)}return e.endsWith("/")?e.slice(0,-1):e}(e.baseUrl),this.defaultHeaders=e.headers||{},this.defaultTimeout=e.timeout||3e4,this.schemaValidator=e.schemaValidator||u(),this.requestInterceptors=e.requestInterceptors||[],this.responseInterceptors=e.responseInterceptors||[],this.defaultRetryOptions=e.retryOptions}addRequestInterceptor(e){this.requestInterceptors.push(e)}addResponseInterceptor(e){this.responseInterceptors.push(e)}setSchemaValidator(e){this.schemaValidator=e}async shouldRetry(a,o,n){if(!1===n)return!1;const i=this.getRetryOptions(n);if(o>=i.maxRetries)return!1;if("function"==typeof i.shouldRetry)try{return await i.shouldRetry(a,o)}catch(c){console.warn("Custom shouldRetry function failed:",c)}return!!(a instanceof t&&i.retryNetworkErrors)||(!!(a instanceof e&&i.retryStatusCodes.includes(a.status))||!(a instanceof r)&&a instanceof s)}getRetryDelay(e,t){const r=t.retryDelay*Math.pow(t.backoffFactor,e),s=Math.min(r,t.maxRetryDelay),a=s+.2*s*(2*Math.random()-1);return Math.max(1,Math.floor(a))}getRetryOptions(e){return!1===e?{...l,maxRetries:0}:!0===e?{...l,...this.defaultRetryOptions}:"object"==typeof e?{...l,...this.defaultRetryOptions,...e}:{...l,...this.defaultRetryOptions}}sleep(e){return new Promise(t=>setTimeout(t,e))}async request(e,r,s={}){let a=0;for(;;)try{return await this.executeRequest(e,r,s)}catch(o){if(!(o instanceof Error))throw new t(String(o),void 0);if(await this.shouldRetry(o,a,s.retry)){const e=this.getRetryOptions(s.retry),t=this.getRetryDelay(a,e);await this.sleep(t),a++;continue}throw o}}async executeRequest(i,c,d={}){let u=this.resolveUrl(c,d.pathParams),h={url:u,method:i,params:d.params,headers:this.prepareHeaders(d.headers),body:d.body,fetchOptions:{credentials:d.credentials,cache:d.cache,mode:d.mode,redirect:d.redirect}};for(const e of this.requestInterceptors)try{h=await e(h)}catch(b){throw new o(`Request interceptor failed: ${b instanceof Error?b.message:String(b)}`,"request",u,i,b instanceof Error?b:void 0)}if(u=h.url,h.params&&Object.keys(h.params).length>0){const e=new URLSearchParams;for(const[r,s]of Object.entries(h.params))void 0!==s&&e.append(r,String(s));const t=e.toString();t&&(u+=(u.includes("?")?"&":"?")+t)}const l={method:h.method,headers:h.headers,...h.fetchOptions};if(void 0!==h.body&&("POST"===h.method||"PUT"===h.method||"PATCH"===h.method))if(h.body instanceof FormData||h.body instanceof Blob||h.body instanceof ArrayBuffer||h.body instanceof URLSearchParams||"string"==typeof h.body)l.body=h.body;else try{l.body=JSON.stringify(h.body)}catch(b){throw new n(`Failed to serialize request body: ${b instanceof Error?b.message:"Invalid data structure"}`,b instanceof Error?b:void 0)}const p=d.timeout||this.defaultTimeout,f=new AbortController,m=setTimeout(()=>f.abort(),p),y=h.signal||d.signal;let w;const E=y?(()=>{const e=this.mergeAbortSignals(y,f.signal);return w=e.cleanup,e.signal})():f.signal;try{const e=await fetch(u,{...l,signal:E});let t=await this.processResponse(e,d,i,u);return d.schema&&(t.data=this.validateResponseData(d.schema,t.data)),t}catch(b){if(b instanceof DOMException&&"AbortError"===b.name||b instanceof Error&&"AbortError"===b.name||b instanceof Error&&b.message.toLowerCase().includes("timeout"))throw new s(`Request timed out after ${p}ms`,b instanceof Error?b:void 0);if(b instanceof e||b instanceof r||b instanceof o||b instanceof a||b instanceof n)throw b;throw new t(b instanceof Error?b.message:String(b),b instanceof Error?b:void 0)}finally{clearTimeout(m),w?.()}}validateWithSchema(e,t,s){try{return this.schemaValidator.validate(e,t)}catch(a){throw new r(`${s}: ${a instanceof Error?a.message:"Unknown error"}`,e,t,a instanceof Error?a:void 0)}}validateResponseData(e,t){return this.validateWithSchema(e,t,"Response schema validation failed")}validateSchema(e,t){return this.validateWithSchema(e,t,"Schema validation failed")}prepareHeaders(e={}){const t=new Headers;for(const[r,s]of Object.entries(this.defaultHeaders))null!=s&&t.set(r,String(s));for(const[r,s]of Object.entries(e))null!=s&&t.set(r,String(s));return t}extractHeaders(e){const t={};return e.forEach((e,r)=>{t[r]=e}),t}createHttpError(t,r,s,a,o,n){return new e(`Request failed with status code ${t.status}`,t.status,o||t.statusText,r,t,s,a,n)}async parseResponseBody(e,t){const r=e.headers.get("content-type")??"";try{if("text"===t.responseType)return await e.text();if("blob"===t.responseType)return await e.blob();if("arrayBuffer"===t.responseType)return await e.arrayBuffer();if(r.includes("application/json")){const t=await e.text();return t?JSON.parse(t):null}return await e.text()}catch(s){if(204===e.status)return;if(r.includes("application/json")&&s instanceof SyntaxError)throw new Error(`Failed to parse JSON response: ${s.message}`);throw s}}async processResponse(e,t,r,s){const a=this.extractHeaders(e.headers),n=t.validateStatus||(e=>e>=200&&e<300),i=await this.parseResponseBody(e,t);if(!n(e.status))throw this.createHttpError(e,i,s,r);const c={data:i,status:e.status,statusText:e.statusText,headers:a,method:r,url:s,raw:e};let d=c;const u=c.status;for(const l of this.responseInterceptors)try{d=await l(d)}catch(h){throw new o(`Response interceptor failed: ${h instanceof Error?h.message:String(h)}`,"response",s,r,h instanceof Error?h:void 0)}if(d.status!==u&&!n(d.status))throw this.createHttpError(e,d.data,s,r,d.statusText);return d}mergeAbortSignals(e,t){if(e.aborted||t.aborted){const e=new AbortController;return e.abort(),{signal:e.signal}}const r=new AbortController,s=()=>{r.abort(),a()},a=()=>{e.removeEventListener("abort",s),t.removeEventListener("abort",s)};return e.addEventListener("abort",s),t.addEventListener("abort",s),{signal:r.signal,cleanup:a}}get(e,t){return this.request("GET",e,t||{})}post(e,t,r){return this.request("POST",e,{...r||{},body:t})}put(e,t,r){return this.request("PUT",e,{...r||{},body:t})}patch(e,t,r){return this.request("PATCH",e,{...r||{},body:t})}delete(e,t){return this.request("DELETE",e,t||{})}validatePathParams(e,t){if(!t){const t=this.extractRequiredPathParams(e);if(t.length>0)throw new a(`Missing required path parameters for URL "${e}": ${t.join(", ")}. Please provide pathParams: { ${t.map(e=>`${e}: value`).join(", ")} }`,e,t,[]);return}const r=this.extractRequiredPathParams(e),s=Object.keys(t),o=r.filter(e=>!s.includes(e));if(o.length>0)throw new a(`Missing required path parameters: ${o.join(", ")}. Provided: ${s.join(", ")}`,e,r,s)}extractRequiredPathParams(e){const t=e.match(/:([a-zA-Z0-9_]+)/g);return t?t.map(e=>e.slice(1)):[]}resolveUrl(e,t){this.validatePathParams(e,t);const r=t?h(e,t):e;if(/^https?:\/\//i.test(r))return r;const s=r.startsWith("/")?r.slice(1):r;return`${this.baseUrl}/${s}`}},exports.HttpError=e,exports.InterceptorError=o,exports.NetworkError=t,exports.PathParameterError=a,exports.SchemaValidationError=r,exports.SerializationError=n,exports.TimeoutError=s,exports.createSchemaValidator=u,exports.createStandardSchemaValidator=d,exports.generatePath=h,exports.isStandardSchema=i,exports.standardSchemaAdapter=c;
 //# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,891 @@
+/**
+ * Create a default schema validator that supports Standard Schema.
+ *
+ * This validator only works with schemas that implement the Standard Schema
+ * interface. For full support of Zod, Valibot, and Arktype, use the
+ * appropriate validator from their respective packages.
+ *
+ * @returns A schema validator instance
+ *
+ * @example
+ * ```ts
+ * import { createSchemaValidator } from '1000fetches'
+ *
+ * const validator = createSchemaValidator();
+ *
+ * // Use with HttpClient
+ * const client = new HttpClient({
+ *   schemaValidator: validator
+ * });
+ * ```
+ */
+export declare function createSchemaValidator(): SchemaValidator;
+
+/**
+ * Creates a schema validator that supports Standard Schema V1 implementations
+ *
+ * Provides a validator that can work with any schema library that implements
+ * the Standard Schema V1 specification, enabling interoperability between
+ * different validation libraries.
+ *
+ * @returns SchemaValidator that supports Standard Schema V1
+ *
+ * @example
+ * ```ts
+ * const validator = createStandardSchemaValidator();
+ * const client = new HttpClient({ schemaValidator: validator });
+ * ```
+ */
+export declare function createStandardSchemaValidator(): SchemaValidator;
+
+declare type ExtractRouteParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<Rest> : T extends `${string}:${infer Param}` ? Param : never;
+
+/**
+ * Interpolates parameters into a URL template
+ * Similar to React Router's generatePath function
+ *
+ * @example
+ * ```ts
+ * const path = generatePath('/users/:id/posts/:postId', { id: '123', postId: '456' });
+ * // => '/users/123/posts/456'
+ * ```
+ */
+export declare function generatePath<Path extends string>(path: Path, params?: PathParams<Path>): string;
+
+declare type HasRequiredParams<T extends string> = T extends `${string}:${string}` ? true : false;
+
+/**
+ * A modern, type-safe HTTP client with built-in schema validation, interceptors, retry logic, and compile-time path parameter validation.
+ *
+ * The HttpClient provides a fluent API for making HTTP requests with full TypeScript support,
+ * automatic retry logic, request/response interceptors, and schema validation using popular
+ * validation libraries like Zod, Valibot, and Arktype.
+ *
+ * @example
+ * ```ts
+ * import { HttpClient } from '1000fetches'
+ * import { z } from 'zod'
+ *
+ * // Create a client instance
+ * const client = new HttpClient({
+ *   baseUrl: 'https://api.example.com',
+ *   timeout: 5000,
+ *   headers: { 'Authorization': 'Bearer token' }
+ * });
+ *
+ * const userSchema = z.object({
+ *   id: z.string(),
+ *   name: z.string(),
+ *   email: z.string()
+ * });
+ *
+ * const response = await client.get('/users/:id', {
+ *   pathParams: { id: '123' },
+ *   schema: userSchema
+ * });
+ */
+export declare class HttpClient {
+    private baseUrl;
+    private defaultHeaders;
+    private defaultTimeout;
+    private schemaValidator;
+    private requestInterceptors;
+    private responseInterceptors;
+    private defaultRetryOptions?;
+    /**
+     * Create a new HttpClient instance.
+     *
+     * @param options - Configuration options for the HTTP client
+     *
+     * @example
+     * ```ts
+     * // Basic configuration
+     * const client = new HttpClient({
+     *   baseUrl: 'https://api.example.com'
+     * });
+     *
+     * // With custom headers and timeout
+     * const client = new HttpClient({
+     *   baseUrl: 'https://api.example.com',
+     *   headers: { 'Authorization': 'Bearer token' },
+     *   timeout: 10000
+     * });
+     *
+     * // With custom schema validator
+     * const client = new HttpClient({
+     *   baseUrl: 'https://api.example.com',
+     *   schemaValidator: createCustomValidator()
+     * });
+     *
+     * // With retry configuration
+     * const client = new HttpClient({
+     *   baseUrl: 'https://api.example.com',
+     *   retryOptions: {
+     *     maxRetries: 5,
+     *     retryDelay: 1000,
+     *     retryStatusCodes: [500, 502, 503]
+     *   }
+     * });
+     * ```
+     */
+    constructor(options?: HttpClientOptions);
+    /**
+     * Add a request interceptor to modify requests before they're sent.
+     *
+     * Request interceptors are executed in the order they were added and can modify
+     * the request context before it's sent to the server. This is useful for adding
+     * authentication headers, logging, or transforming request data.
+     *
+     * @param interceptor - The interceptor function to add
+     *
+     * @example
+     * ```ts
+     * // Add authentication headers to all requests
+     * client.addRequestInterceptor((context) => {
+     *   context.headers.set('Authorization', `Bearer ${getToken()}`);
+     *   return context;
+     * });
+     *
+     * // Change the base URL for specific endpoints
+     * client.addRequestInterceptor((context) => {
+     *   if (context.url.includes('/special/')) {
+     *     context.url = context.url.replace('api.example.com', 'special-api.example.com');
+     *   }
+     *   return context;
+     * });
+     *
+     * // Log all outgoing requests
+     * client.addRequestInterceptor((context) => {
+     *   console.log(`Making ${context.method} request to ${context.url}`);
+     *   return context;
+     * });
+     * ```
+     */
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    /**
+     * Add a response interceptor to process responses before they're returned.
+     *
+     * Response interceptors are executed in the order they were added and can modify
+     * the response data before it's returned to the caller. This is useful for
+     * transforming data, logging responses, or handling global error conditions.
+     *
+     * @param interceptor - The interceptor function to add
+     *
+     * @example
+     * ```ts
+     * // Log all responses
+     * client.addResponseInterceptor((response) => {
+     *   console.log(`Response from ${response.raw.url}: ${response.status}`);
+     *   return response;
+     * });
+     *
+     * // Transform response data
+     * client.addResponseInterceptor((response) => {
+     *   if (Array.isArray(response.data)) {
+     *     response.data = response.data.map(item => transformItem(item));
+     *   }
+     *   return response;
+     * });
+     *
+     * // Handle 401 responses by refreshing the token and retrying
+     * client.addResponseInterceptor(async (response) => {
+     *   if (response.status === 401) {
+     *     await refreshToken();
+     *     // Make a new request (will use updated token)
+     *     return await client.request(response.raw.method, response.raw.url);
+     *   }
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * Set a custom schema validator for request/response validation
+     *
+     * @param validator - The schema validator to use for validation
+     *
+     * @example
+     * ```ts
+     * // Set a custom validator
+     * client.setSchemaValidator(customValidator);
+     * ```
+     */
+    /**
+     * Set a custom schema validator for the client.
+     *
+     * This allows you to use a different validation library or custom validation logic
+     * for all requests made by this client instance.
+     *
+     * @param validator - The schema validator to use for all validation operations
+     *
+     * @example
+     * ```ts
+     * import { createCustomValidator } from './custom-validator'
+     *
+     * // Set a custom validator
+     * client.setSchemaValidator(createCustomValidator());
+     *
+     * // Now all requests will use the custom validator
+     * const response = await client.post('/users', userData, {
+     *   schema: customUserSchema
+     * });
+     * ```
+     */
+    setSchemaValidator(validator: SchemaValidator): void;
+    /**
+     * Determines if a request should be retried based on error type and retry configuration
+     *
+     * @param error - The error that occurred during the request
+     * @param retryCount - Current retry attempt number
+     * @param retryOptions - Retry configuration for this request
+     * @returns Promise resolving to whether the request should be retried
+     */
+    private shouldRetry;
+    /**
+     * Calculates the delay for the next retry attempt using exponential backoff with jitter
+     *
+     * @param retryCount - Current retry attempt number
+     * @param options - Retry configuration options
+     * @returns Delay in milliseconds before the next retry attempt
+     */
+    private getRetryDelay;
+    /**
+     * Merges provided retry options with default configuration
+     *
+     * @param retryOptions - Retry options to merge with defaults
+     * @returns Complete retry configuration with all required properties
+     */
+    private getRetryOptions;
+    /**
+     * Creates a promise that resolves after the specified delay
+     *
+     * @param ms - Delay duration in milliseconds
+     * @returns Promise that resolves after the delay
+     */
+    private sleep;
+    /**
+     * Makes an HTTP request with automatic retry capability
+     *
+     * @param method - HTTP method to use for the request
+     * @param url - URL path for the request (supports path parameters)
+     * @param options - Request configuration options
+     * @returns Promise resolving to the response data
+     *
+     * @example
+     * ```ts
+     * // Simple GET request
+     * const response = await client.request('GET', '/users/1');
+     *
+     * // POST request with body and path parameters
+     * const response = await client.request('POST', '/users/:id/posts', {
+     *   pathParams: { id: 1 },
+     *   body: { title: 'New Post', content: 'Hello World' },
+     *   schema: userPostSchema
+     * });
+     * ```
+     */
+    request<Path extends string = string, TResponse = unknown, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(method: HttpMethod, url: Path, options?: TypedRequestOptions<TBody, TResponse, TParams, Path>): Promise<ResponseType_2<TResponse>>;
+    /**
+     * Executes a single HTTP request without retry logic
+     *
+     * @param method - HTTP method for the request
+     * @param url - URL path with optional path parameters
+     * @param options - Request configuration and validation options
+     * @returns Promise resolving to the response data
+     */
+    private executeRequest;
+    private validateWithSchema;
+    private validateResponseData;
+    /**
+     * Public method to validate data against any schema
+     *
+     * @param schema - Schema to validate against
+     * @param data - Data to validate
+     * @returns Validated data
+     *
+     * @example
+     * ```ts
+     * const validatedUser = client.validateSchema(userSchema, userData);
+     * ```
+     */
+    /**
+     * Validate data against a schema using the configured schema validator.
+     *
+     * This method uses the same schema validator that's configured for the client,
+     * ensuring consistent validation behavior across all requests.
+     *
+     * @template T - The expected type after validation
+     * @param schema - The schema to validate against (Zod, Valibot, or Arktype)
+     * @param data - The data to validate
+     *
+     * @returns The validated data with the correct type
+     *
+     * @throws {SchemaValidationError} If the data doesn't match the schema
+     *
+     * @example
+     * ```ts
+     * import { z } from 'zod'
+     *
+     * const userSchema = z.object({
+     *   id: z.string(),
+     *   name: z.string(),
+     *   email: z.email()
+     * });
+     *
+     * // Validate data manually
+     * try {
+     *   const validatedUser = client.validateSchema(userSchema, userData);
+     *   console.log('Valid user:', validatedUser);
+     * } catch (error) {
+     *   console.error('Invalid user data:', error);
+     * }
+     *
+     * // This is equivalent to the validation that happens automatically
+     * // when you use schema in requests
+     * ```
+     */
+    validateSchema<T>(schema: Schema<T>, data: unknown): T;
+    /**
+     * Prepares headers for HTTP requests by merging default and custom headers
+     *
+     * @param customHeaders - Additional headers to include in the request
+     * @returns Headers object with all headers properly set
+     */
+    private prepareHeaders;
+    /**
+     * Extracts headers from Headers object into a plain record
+     *
+     * @param headers - Headers object to extract from
+     * @returns Record containing header key-value pairs
+     */
+    private extractHeaders;
+    /**
+     * Creates an HttpError instance with response details
+     *
+     * @param response - The HTTP response that caused the error
+     * @param data - Response data (if any)
+     * @param url - The URL that was requested
+     * @param method - The HTTP method used
+     * @param customStatusText - Optional custom status text
+     * @param cause - Optional underlying error that caused this HTTP error
+     * @returns HttpError instance with complete error information
+     */
+    private createHttpError;
+    private parseResponseBody;
+    private processResponse;
+    private mergeAbortSignals;
+    /**
+     * Send a GET request with schema validation (type inferred from schema).
+     *
+     * @example
+     * // JSON response
+     * const response = await client.get('/users/:id', {
+     *   pathParams: { id: '123' },
+     *   schema: z.object({ id: z.string(), name: z.string() })
+     * })
+     *
+     * @example
+     * // Blob response
+     * const response = await client.get('/avatar', {
+     *   responseType: 'blob',
+     *   schema: z.instanceof(Blob)
+     * })
+     *
+     * @example
+     * // Text response
+     * const response = await client.get('/raw', {
+     *   responseType: 'text',
+     *   schema: z.string()
+     * })
+     */
+    get<TResponse, Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, options: TypedRequestOptions<void, TResponse, TParams, Path> & {
+        schema: Schema<TResponse>;
+    }): Promise<ResponseType_2<TResponse>>;
+    /**
+     * Send a GET request without schema (response.data is unknown).
+     *
+     * @example
+     * const response = await client.get('/users')
+     */
+    get<Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, options?: Omit<TypedRequestOptions<void, unknown, TParams, Path>, 'schema'>): Promise<ResponseType_2<unknown>>;
+    /**
+     * Send a POST request with schema validation (type inferred from schema).
+     *
+     * @example
+     * const response = await client.post('/users', userData, {
+     *   schema: z.object({ id: z.string(), name: z.string() })
+     * })
+     */
+    post<TResponse, Path extends string = string, TParams extends RequestParamsType = RequestParamsType, TBody = unknown>(url: Path, body: TBody | undefined, options: Omit<TypedRequestOptions<TBody, TResponse, TParams, Path>, 'body'> & {
+        schema: Schema<TResponse>;
+    }): Promise<ResponseType_2<TResponse>>;
+    /**
+     * Send a POST request without schema (response.data is unknown).
+     *
+     * @example
+     * const response = await client.post('/users', userData)
+     */
+    post<Path extends string = string, TParams extends RequestParamsType = RequestParamsType, TBody = unknown>(url: Path, body?: TBody, options?: Omit<TypedRequestOptions<TBody, unknown, TParams, Path>, 'body' | 'schema'>): Promise<ResponseType_2<unknown>>;
+    /**
+     * Send a PUT request with schema validation (type inferred from schema).
+     *
+     * @example
+     * const response = await client.put('/users/:id', updatedData, {
+     *   pathParams: { id: '123' },
+     *   schema: z.object({ id: z.string(), name: z.string() })
+     * })
+     */
+    put<TResponse, Path extends string = string, TParams extends RequestParamsType = RequestParamsType, TBody = unknown>(url: Path, body: TBody | undefined, options: Omit<TypedRequestOptions<TBody, TResponse, TParams, Path>, 'body'> & {
+        schema: Schema<TResponse>;
+    }): Promise<ResponseType_2<TResponse>>;
+    /**
+     * Send a PUT request without schema (response.data is unknown).
+     *
+     * @example
+     * const response = await client.put('/users/:id', updatedData, {
+     *   pathParams: { id: '123' }
+     * })
+     */
+    put<Path extends string = string, TParams extends RequestParamsType = RequestParamsType, TBody = unknown>(url: Path, body?: TBody, options?: Omit<TypedRequestOptions<TBody, unknown, TParams, Path>, 'body' | 'schema'>): Promise<ResponseType_2<unknown>>;
+    /**
+     * Send a PATCH request with schema validation (type inferred from schema).
+     *
+     * @example
+     * const response = await client.patch('/users/:id', partialData, {
+     *   pathParams: { id: '123' },
+     *   schema: z.object({ id: z.string(), name: z.string() })
+     * })
+     */
+    patch<TResponse, Path extends string = string, TParams extends RequestParamsType = RequestParamsType, TBody = unknown>(url: Path, body: TBody | undefined, options: Omit<TypedRequestOptions<TBody, TResponse, TParams, Path>, 'body'> & {
+        schema: Schema<TResponse>;
+    }): Promise<ResponseType_2<TResponse>>;
+    /**
+     * Send a PATCH request without schema (response.data is unknown).
+     *
+     * @example
+     * const response = await client.patch('/users/:id', partialData, {
+     *   pathParams: { id: '123' }
+     * })
+     */
+    patch<Path extends string = string, TParams extends RequestParamsType = RequestParamsType, TBody = unknown>(url: Path, body?: TBody, options?: Omit<TypedRequestOptions<TBody, unknown, TParams, Path>, 'body' | 'schema'>): Promise<ResponseType_2<unknown>>;
+    /**
+     * Send a DELETE request with schema validation (type inferred from schema).
+     *
+     * @example
+     * const response = await client.delete('/users/:id', {
+     *   pathParams: { id: '123' },
+     *   schema: z.object({ success: z.boolean() })
+     * })
+     */
+    delete<TResponse, Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, options: TypedRequestOptions<void, TResponse, TParams, Path> & {
+        schema: Schema<TResponse>;
+    }): Promise<ResponseType_2<TResponse>>;
+    /**
+     * Send a DELETE request without schema (response.data is unknown).
+     *
+     * @example
+     * const response = await client.delete('/users/:id', {
+     *   pathParams: { id: '123' }
+     * })
+     */
+    delete<Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, options?: Omit<TypedRequestOptions<void, unknown, TParams, Path>, 'schema'>): Promise<ResponseType_2<unknown>>;
+    /**
+     * Validates path parameters against the URL template
+     *
+     * @param url - URL template with path parameters (e.g., '/users/:id')
+     * @param pathParams - Path parameters to validate
+     * @throws Error if required path parameters are missing or invalid
+     */
+    private validatePathParams;
+    /**
+     * Extracts required path parameters from a URL template
+     *
+     * @param url - URL template to extract parameters from
+     * @returns Array of required parameter names
+     */
+    private extractRequiredPathParams;
+    /**
+     * Resolves a URL template with path parameters and base URL
+     *
+     * @param url - URL template with optional path parameters
+     * @param pathParams - Path parameters to interpolate into the URL
+     * @returns Fully resolved URL with base URL and path parameters applied
+     */
+    private resolveUrl;
+}
+
+declare interface HttpClientError {
+    name: string;
+    message: string;
+    cause?: Error;
+    stack?: string;
+}
+
+export declare interface HttpClientOptions {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    schemaValidator?: SchemaValidator;
+    requestInterceptors?: RequestInterceptor[];
+    responseInterceptors?: ResponseInterceptor[];
+    retryOptions?: RetryOptions;
+}
+
+export declare class HttpError<TErrorData = unknown> extends Error implements HttpClientError {
+    readonly name = "HttpError";
+    readonly status: number;
+    readonly statusText: string;
+    readonly data: TErrorData;
+    readonly response: Response;
+    readonly url: string;
+    readonly method: string;
+    readonly cause?: Error;
+    constructor(message: string, status: number, statusText: string, data: TErrorData, response: Response, url: string, method: string, cause?: Error);
+}
+
+export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+
+export declare class InterceptorError extends Error implements HttpClientError {
+    readonly name = "InterceptorError";
+    readonly interceptorType: 'request' | 'response';
+    readonly url?: string;
+    readonly method?: string;
+    readonly cause?: Error;
+    constructor(message: string, interceptorType: 'request' | 'response', url?: string, method?: string, cause?: Error);
+}
+
+/**
+ * Type guard to check if an object conforms to the Standard Schema V1 specification
+ *
+ * Validates that an object has the required structure and properties
+ * to be considered a valid Standard Schema implementation.
+ *
+ * @param obj - The object to check
+ * @returns True if the object is a valid Standard Schema V1 implementation
+ *
+ * @example
+ * ```ts
+ * if (isStandardSchema(schema)) {
+ *   // Use the schema with type safety
+ *   const result = schema['~standard'].validate(data);
+ * }
+ * ```
+ */
+export declare function isStandardSchema(obj: unknown): obj is StandardSchemaV1;
+
+export declare class NetworkError extends Error implements HttpClientError {
+    readonly name = "NetworkError";
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+
+export declare class PathParameterError extends Error implements HttpClientError {
+    readonly name = "PathParameterError";
+    readonly url: string;
+    readonly requiredParams: string[];
+    readonly providedParams: string[];
+    readonly cause?: Error;
+    constructor(message: string, url: string, requiredParams: string[], providedParams: string[], cause?: Error);
+}
+
+declare type PathParams<Path extends string> = ValidateNoOptionalParams<Path> extends never ? never : {
+    [K in ExtractRouteParams<Path>]: string | number;
+};
+
+/**
+ * Request context that interceptors can modify
+ */
+export declare interface RequestContext<TBody = unknown> {
+    /** The URL to send the request to */
+    url: string;
+    /** The HTTP method (GET, POST, etc.) */
+    method: HttpMethod;
+    /** Query parameters to append to the URL */
+    params?: RequestParamsType;
+    /** Headers to send with the request */
+    headers: Headers;
+    /** Request body */
+    body?: TBody;
+    /** AbortSignal for request cancellation */
+    signal?: AbortSignal;
+    /** Fetch options */
+    fetchOptions: Omit<RequestInit, 'body' | 'headers' | 'signal' | 'method'>;
+}
+
+/**
+ * Request interceptor function
+ * Can modify request context before the request is sent
+ */
+export declare type RequestInterceptor = <TBody = unknown>(context: RequestContext<TBody>) => RequestContext<TBody> | Promise<RequestContext<TBody>>;
+
+export declare interface RequestOptions<TBody = unknown> {
+    headers?: Record<string, string>;
+    params?: RequestParamsType;
+    body?: TBody;
+    timeout?: number;
+    signal?: AbortSignal;
+    validateStatus?: (status: number) => boolean;
+    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer';
+    cache?: RequestCache;
+    credentials?: RequestCredentials;
+    mode?: RequestMode;
+    redirect?: RequestRedirect;
+    retry?: RetryOptions | boolean;
+}
+
+declare type RequestParamsType = Record<string, string | number | boolean | undefined>;
+
+declare type RequirePathParams<Path extends string, T> = HasRequiredParams<Path> extends true ? T & {
+    pathParams: PathParams<Path>;
+} : T;
+
+/**
+ * Response interceptor function
+ * Can modify response data after the request returns
+ */
+export declare type ResponseInterceptor = <T>(response: ResponseType_2<T>) => ResponseType_2<T> | Promise<ResponseType_2<T>>;
+
+declare interface ResponseType_2<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    method: HttpMethod;
+    url: string;
+    raw: Response;
+}
+export { ResponseType_2 as ResponseType }
+
+export declare interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Base delay between retries in milliseconds (default: 300) */
+    retryDelay?: number;
+    /** Exponential backoff factor (default: 2) */
+    backoffFactor?: number;
+    /** Status codes that should trigger a retry (default: [408, 429, 500, 502, 503, 504]) */
+    retryStatusCodes?: number[];
+    /** Whether to retry on network errors (default: true) */
+    retryNetworkErrors?: boolean;
+    /** Maximum retry delay in milliseconds (default: 30_000) */
+    maxRetryDelay?: number;
+    /** Custom function to determine if a request should be retried */
+    shouldRetry?: (error: Error, retryCount: number) => boolean | Promise<boolean>;
+}
+
+export declare type Schema<T = unknown> = StandardSchemaV1<unknown, T>;
+
+export declare class SchemaValidationError extends Error implements HttpClientError {
+    readonly name = "SchemaValidationError";
+    readonly schema: unknown;
+    readonly data: unknown;
+    readonly cause?: Error;
+    constructor(message: string, schema: unknown, data: unknown, cause?: Error);
+}
+
+/**
+ * Interface for schema validators that can validate data against schemas.
+ *
+ * This interface allows you to create custom schema validators that work
+ * with different validation libraries (Zod, Valibot, Arktype, etc.).
+ */
+export declare interface SchemaValidator {
+    /**
+     * Validate data against a schema.
+     *
+     * @template T - The expected type after validation
+     * @param schema - The schema to validate against
+     * @param data - The data to validate
+     * @returns The validated data with the correct type
+     * @throws {SchemaValidationError} If the data doesn't match the schema
+     */
+    validate<T>(schema: Schema<T>, data: unknown): T;
+    /**
+     * Check if an object is a valid schema.
+     *
+     * @param obj - The object to check
+     * @returns True if the object is a valid schema, false otherwise
+     */
+    isSchema(obj: unknown): boolean;
+}
+
+export declare class SerializationError extends Error implements HttpClientError {
+    readonly name = "SerializationError";
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+
+/**
+ * Creates an adapter for Standard Schema V1 implementations
+ *
+ * Converts Standard Schema validation results into a format compatible
+ * with the HTTP client's schema validation system.
+ *
+ * @param schema - The Standard Schema V1 implementation to adapt
+ * @returns Adapter object with parse method
+ *
+ * @example
+ * ```ts
+ * const zodAdapter = standardSchemaAdapter(zodUserSchema);
+ * const validatedUser = zodAdapter.parse(userData);
+ * ```
+ */
+export declare function standardSchemaAdapter<T>(schema: StandardSchemaV1<unknown, T>): {
+    /**
+     * Parses and validates data using the Standard Schema
+     *
+     * @param data - The data to validate
+     * @returns The validated and typed data
+     * @throws Error if validation fails
+     */
+    parse: (data: unknown) => T;
+};
+
+/**
+ * Standard Schema V1 interface implementation
+ *
+ * This interface defines the structure for schema validation libraries
+ * that conform to the Standard Schema specification.
+ *
+ * @see https://github.com/standard-schema/standard-schema
+ */
+export declare interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties containing validation logic and metadata */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+
+/**
+ * Namespace containing Standard Schema V1 type definitions
+ *
+ * Provides type-safe interfaces for schema validation results,
+ * error handling, and type inference.
+ */
+export declare namespace StandardSchemaV1 {
+    /**
+     * Core properties interface for Standard Schema V1
+     *
+     * Contains the essential metadata and validation function
+     * that every Standard Schema implementation must provide.
+     */
+    export interface Props<Input = unknown, Output = Input> {
+        /** The version number of the Standard Schema specification */
+        readonly version: 1;
+        /** The name of the schema validation library (e.g., 'zod', 'valibot') */
+        readonly vendor: string;
+        /**
+         * Validates unknown input values against the schema
+         *
+         * @param value - The value to validate
+         * @returns Promise or direct result containing validation outcome
+         */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Type information for input and output types */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /**
+     * Union type representing the result of schema validation
+     *
+     * Can be either a successful validation with the validated value,
+     * or a failed validation with error details.
+     */
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    /**
+     * Interface for successful validation results
+     *
+     * Contains the validated and typed output value.
+     */
+    export interface SuccessResult<Output> {
+        /** The validated and typed output value */
+        readonly value: Output;
+        /** Undefined since validation succeeded */
+        readonly issues?: undefined;
+    }
+    /**
+     * Interface for failed validation results
+     *
+     * Contains detailed error information about validation failures.
+     */
+    export interface FailureResult {
+        /** Array of validation error details */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /**
+     * Interface for individual validation error details
+     *
+     * Provides error message and optional path information
+     * to help identify where validation failed.
+     */
+    export interface Issue {
+        /** Human-readable error message describing the validation failure */
+        readonly message: string;
+        /**
+         * Path to the property that failed validation
+         *
+         * Useful for nested object validation to pinpoint the exact location
+         * of validation failures.
+         */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /**
+     * Interface for path segment information in validation errors
+     *
+     * Used to provide detailed path information for validation failures
+     * in complex nested structures.
+     */
+    export interface PathSegment {
+        /** The property key representing this path segment */
+        readonly key: PropertyKey;
+    }
+    /**
+     * Interface for type information associated with a schema
+     *
+     * Provides compile-time type information for input and output types
+     * to enable better TypeScript integration and IntelliSense support.
+     */
+    export interface Types<Input = unknown, Output = Input> {
+        /** The input type that the schema expects */
+        readonly input: Input;
+        /** The output type that the schema produces after validation */
+        readonly output: Output;
+    }
+    /**
+     * Type utility to infer the input type from a Standard Schema
+     *
+     * Extracts the input type that a schema expects for validation.
+     *
+     * @example
+     * ```ts
+     * type UserInput = StandardSchemaV1.InferInput<typeof userSchema>
+     * ```
+     */
+    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /**
+     * Type utility to infer the output type from a Standard Schema
+     *
+     * Extracts the output type that a schema produces after validation.
+     *
+     * @example
+     * ```ts
+     * type UserOutput = StandardSchemaV1.InferOutput<typeof userSchema>
+     * ```
+     */
+    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+
+export declare type StrictTypedRequestOptions<TBody = unknown, TResponse = unknown, TParams extends RequestParamsType = RequestParamsType, Path extends string = string> = RequirePathParams<Path, TypedRequestOptions<TBody, TResponse, TParams, Path>>;
+
+export declare class TimeoutError extends Error implements HttpClientError {
+    readonly name = "TimeoutError";
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+
+export declare interface TypedRequestOptions<TBody = unknown, TResponse = unknown, TParams extends RequestParamsType = RequestParamsType, Path extends string = string> extends Omit<RequestOptions<TBody>, 'params'> {
+    params?: TParams;
+    schema?: Schema<TResponse>;
+    pathParams?: PathParams<Path>;
+}
+
+declare type ValidateNoOptionalParams<T extends string> = T extends `${string}:${string}?${string}` ? never : T extends `${string}:${string}/${infer Rest}` ? ValidateNoOptionalParams<Rest> : T;
+
+export { }

package/dist/index.es.js

@@ -908,6 +908,7 @@ export {
   NetworkError,
   PathParameterError,
   SchemaValidationError,
+  SerializationError,
   TimeoutError,
   createSchemaValidator,
   createStandardSchemaValidator,

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "1000fetches",
-  "version": "0.1.0",
-  "description": "A modern, type-safe HTTP client for TypeScript with built-in schema validation, interceptors, retry logic, and compile-time path parameter validation. Features full TypeScript support, automatic retry logic, request/response interceptors, and schema validation using popular libraries like Zod, Valibot, and ArkType.",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
+  "version": "0.1.1",
+  "description": "A type-first HTTP client with compile-time path validation, runtime schema verification, smart retry logic, and interceptors — powered by native fetch. Supports Zod, Valibot, ArkType, and any Standard Schema-compatible library.",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.es.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
@@ -15,6 +15,7 @@
   "files": [
     "dist"
   ],
+  "sideEffects": false,
   "scripts": {
     "build": "tsc && vite build",
     "dev": "vite build --watch",
@@ -64,6 +65,7 @@
     "typescript": "5.9.2",
     "valibot": "1.1.0",
     "vite": "7.1.7",
+    "vite-plugin-dts": "4.5.4",
     "vitest": "3.2.4",
     "zod": "4.1.11"
   },