1000fetches 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -1,346 +1,15 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-
-export declare class AsyncSchemaValidationError extends Error implements HttpClientError {
-    readonly name = "AsyncSchemaValidationError";
-    readonly schema: unknown;
-    readonly cause?: Error;
-    constructor(message: string, schema: unknown, cause?: Error);
-}
-
-/**
- * Removes optional suffix from param name (e.g., ":id?" -> "id", ":id" -> "id")
- */
-declare type CleanParamName<S extends string> = S extends `:${infer Name}?` ? Name : S extends `:${infer Name}` ? Name : S;
-
-/**
- * Creates a complete HTTP client with method builders
- */
-export declare function createHttpClient(config?: HttpClientConfig): {
-    get: <Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<never, TParams, Path>] : [options?: EnforcedPathParamsOptions<never, TParams, Path>]) => SchemaableResponse<unknown>;
-    post: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, body?: TBody, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: EnforcedPathParamsOptions<TBody, TParams, Path>]) => SchemaableResponse<unknown>;
-    put: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, body?: TBody, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: EnforcedPathParamsOptions<TBody, TParams, Path>]) => SchemaableResponse<unknown>;
-    patch: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, body?: TBody, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: EnforcedPathParamsOptions<TBody, TParams, Path>]) => SchemaableResponse<unknown>;
-    delete: <Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<never, TParams, Path>] : [options?: EnforcedPathParamsOptions<never, TParams, Path>]) => SchemaableResponse<unknown>;
-    /**
-     * Generic request method for custom HTTP methods and full control
-     */
-    request: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, options?: HttpRequestOptions<TBody, TParams>) => SchemaableResponse<unknown>;
-};
-
-declare type CustomFetch = typeof fetch;
-
-declare interface DownloadStreamingEvent {
-    /** Current data chunk being downloaded */
-    chunk: Uint8Array;
-    /** Total bytes to download (from Content-Length header, undefined if unknown) */
-    totalBytes: number | undefined;
-    /** Bytes already transferred */
-    transferredBytes: number;
-}
-
-declare type EnforcedPathParamsOptions<TBody = unknown, TParams extends RequestParamsType = RequestParamsType, Path extends string = string> = RequirePathParams<Path, Omit<RequestOptions<TBody>, 'params'> & {
-    params?: TParams;
-}>;
-
-declare type ExtractableResponse<T> = Promise<ResponseType_2<T>> & {
-    data(): Promise<T>;
-};
-
-/**
- * Extracts all path parameters from a route
- */
-declare type ExtractRouteParams<T extends string> = NormalizePath<T> extends `${infer _Before}:${infer AfterColon}` ? AfterColon extends `${infer Param}/${infer Rest}` ? CleanParamName<`:${Param}`> | ExtractRouteParams<`/${Rest}`> : CleanParamName<`:${AfterColon}`> : never;
-
-declare type HasRequiredParams<T extends string> = [
-ExtractRouteParams<T>
-] extends [never] ? false : true;
-
-declare const http: {
-    get: <Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<never, TParams, Path>] : [options?: EnforcedPathParamsOptions<never, TParams, Path>]) => SchemaableResponse<unknown>;
-    post: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, body?: TBody, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: EnforcedPathParamsOptions<TBody, TParams, Path>]) => SchemaableResponse<unknown>;
-    put: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, body?: TBody, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: EnforcedPathParamsOptions<TBody, TParams, Path>]) => SchemaableResponse<unknown>;
-    patch: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, body?: TBody, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: EnforcedPathParamsOptions<TBody, TParams, Path>]) => SchemaableResponse<unknown>;
-    delete: <Path extends string = string, TParams extends RequestParamsType = RequestParamsType>(url: Path, ...args: HasRequiredParams<Path> extends true ? [options: EnforcedPathParamsOptions<never, TParams, Path>] : [options?: EnforcedPathParamsOptions<never, TParams, Path>]) => SchemaableResponse<unknown>;
-    /**
-     * Generic request method for custom HTTP methods and full control
-     */
-    request: <Path extends string = string, TBody = unknown, TParams extends RequestParamsType = RequestParamsType>(url: Path, options?: HttpRequestOptions<TBody, TParams>) => SchemaableResponse<unknown>;
-};
-export default http;
-export { http }
-
-export declare interface HttpClientConfig {
-    /** Base URL for all requests */
-    baseUrl?: string;
-    /** Default headers */
-    headers?: HttpHeaders;
-    /** Default timeout */
-    timeout?: number;
-    /** Schema validator */
-    schemaValidator?: SchemaValidator;
-    /** Default retry options */
-    retryOptions?: RetryOptions;
-    /** Custom fetch implementation */
-    fetch?: CustomFetch;
-    /** Custom body serializer */
-    serializeBody?: SerializeBody;
-    /** Custom params serializer */
-    serializeParams?: SerializeParams;
-    /** Request middleware - can modify request before sending */
-    onRequestMiddleware?: <TBody = unknown>(context: RequestContext<TBody>) => RequestContext<TBody> | Promise<RequestContext<TBody>>;
-    /** Response middleware - can modify response after receiving */
-    onResponseMiddleware?: (response: ResponseType_2<unknown>) => ResponseType_2<unknown> | Promise<ResponseType_2<unknown>>;
-}
-
-declare interface HttpClientError {
-    name: string;
-    message: string;
-    cause?: Error;
-    stack?: string;
-}
-
-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 HttpHeaders = Record<string, string>;
-
-export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-
-export declare interface HttpRequestOptions<TBody = unknown, TParams extends RequestParamsType = RequestParamsType> {
-    method?: HttpMethod;
-    headers?: HttpHeaders;
-    /** Query parameters */
-    params?: TParams;
-    /** Path parameters for URL template */
-    pathParams?: Record<string, string | number>;
-    /** Request body */
-    body?: TBody;
-    timeout?: number;
-    signal?: AbortSignal;
-    /** Fetch options */
-    credentials?: RequestCredentials;
-    cache?: RequestCache;
-    mode?: RequestMode;
-    redirect?: RequestRedirect;
-    /** Upload streaming tracking for this specific request */
-    onUploadStreaming?: (event: UploadStreamingEvent) => void;
-    /** Download streaming tracking for this specific request */
-    onDownloadStreaming?: (event: DownloadStreamingEvent) => void;
-    /** Response type override */
-    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
-    retryOptions?: RetryOptions;
-}
-
-declare type InferSchemaOutput<ResponseSchema> = IsZodSchema<ResponseSchema> extends true ? ResponseSchema extends {
-    parse: infer ParseFn;
-} ? ParseFn extends (...args: any[]) => infer R ? R : unknown : unknown : ResponseSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ResponseSchema> : unknown;
-
-declare type IsZodSchema<S> = S extends {
-    _def: any;
-} ? true : false;
-
-export declare class MiddlewareError extends Error implements HttpClientError {
-    readonly name = "MiddlewareError";
-    readonly type: 'request' | 'response';
-    readonly url?: string;
-    readonly method?: string;
-    readonly cause?: Error;
-    constructor(message: string, type: 'request' | 'response', url?: string, method?: string, cause?: Error);
-}
-
-export declare class NetworkError extends Error implements HttpClientError {
-    readonly name = "NetworkError";
-    readonly cause?: Error;
-    constructor(message: string, cause?: Error);
-}
-
-/**
- * Normalizes URL to path only, stripping protocol, host, port, and query
- */
-declare type NormalizePath<T extends string> = StripQuery<StripHost<StripProtocol<T>>>;
-
-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);
-}
-
-/**
- * PathParams type - extracts parameter names and their types
- */
-declare type PathParams<Path extends string> = {
-    [K in ExtractRouteParams<Path>]: string | number;
-};
-
-/**
- * Request context that can be modified by onRequest hook
- */
-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'>;
-}
-
-export declare interface RequestOptions<TBody = unknown> {
-    headers?: HttpHeaders;
-    params?: RequestParamsType;
-    body?: TBody;
-    timeout?: number;
-    signal?: AbortSignal;
-    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    mode?: RequestMode;
-    redirect?: RequestRedirect;
-    retry?: RetryOptions | boolean;
-    onUploadStreaming?: (event: UploadStreamingEvent) => void;
-    onDownloadStreaming?: (event: DownloadStreamingEvent) => void;
-}
-
-declare type RequestParamsType = Record<string, string | number | boolean | (string | number | boolean | undefined | null)[] | undefined | null>;
-
-/**
- * RequirePathParams enforces pathParams when needed
- */
-declare type RequirePathParams<Path extends string, T> = HasRequiredParams<Path> extends true ? T & {
-    pathParams: PathParams<Path>;
-} : T;
-
-declare interface ResponseType_2<T = unknown> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: HttpHeaders;
-    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> | (StandardSchemaV1<unknown, T> & {
-    _output: T;
-}) | (StandardSchemaV1<unknown, T> & {
-    _output?: T;
-});
-
-declare type SchemaableResponse<T> = ExtractableResponse<T> & {
-    schema<S extends Schema>(schema: S): ExtractableResponse<InferSchemaOutput<S>>;
-};
-
-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.).
- */
-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);
-}
-
-declare type SerializeBody<TBody = unknown> = (body: TBody) => BodyInit | null | undefined;
-
-declare type SerializeParams = (params: RequestParamsType) => string;
-
-/**
- * Strips host and optional port from URL, keeping only the path
- * Handles cases like "localhost:3000/users" -> "/users"
- */
-declare type StripHost<T extends string> = T extends `${infer _Host}/${infer Path}` ? `/${Path}` : T;
-
-/**
- * Strips protocol from URL (e.g., https://, http://)
- */
-declare type StripProtocol<T extends string> = T extends `${string}://${infer After}` ? After : T;
-
-/**
- * Strips query string from path (e.g., "/users?x=1" -> "/users")
- * Only strips ? that comes after the path, not ? that's part of path parameters
- */
-declare type StripQuery<T extends string> = T extends `${infer Path}?${infer Query}` ? Query extends `${string}=${string}` | `${string}&${string}` | `${string}=${string}&${string}` ? Path : Query extends `/${string}` ? T : Query extends `` ? T : Path : T;
-
-export declare class TimeoutError extends Error implements HttpClientError {
-    readonly name = "TimeoutError";
-    readonly cause?: Error;
-    constructor(message: string, cause?: Error);
-}
-
-declare interface UploadStreamingEvent {
-    /** Current data chunk being uploaded */
-    chunk: Uint8Array;
-    /** Total bytes to upload (from Content-Length header or body size) */
-    totalBytes: number | undefined;
-    /** Bytes already transferred */
-    transferredBytes: number;
-}
-
-export { }
+export { createHttpClient } from './client';
+export { createSchemaValidator } from './schema';
+export declare const http: {
+    get: <Path extends string = string, TParams extends import('./types').RequestParamsType = import('./types').RequestParamsType>(url: Path, ...args: [import('./utils').AssertSupportedPath<Path>] extends [never] ? [options: never] : import('./utils').HasRequiredParams<import('./utils').AssertSupportedPath<Path>> extends true ? [options: import('./types').EnforcedPathParamsOptions<never, TParams, Path>] : [options?: import('./types').EnforcedPathParamsOptions<never, TParams, Path> | undefined]) => import('./types').SchemaableResponse<unknown>;
+    post: <Path extends string = string, TBody = unknown, TParams extends import('./types').RequestParamsType = import('./types').RequestParamsType>(url: Path, body?: TBody, ...args: [import('./utils').AssertSupportedPath<Path>] extends [never] ? [options: never] : import('./utils').HasRequiredParams<import('./utils').AssertSupportedPath<Path>> extends true ? [options: import('./types').EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: import('./types').EnforcedPathParamsOptions<TBody, TParams, Path> | undefined]) => import('./types').SchemaableResponse<unknown>;
+    put: <Path extends string = string, TBody = unknown, TParams extends import('./types').RequestParamsType = import('./types').RequestParamsType>(url: Path, body?: TBody, ...args: [import('./utils').AssertSupportedPath<Path>] extends [never] ? [options: never] : import('./utils').HasRequiredParams<import('./utils').AssertSupportedPath<Path>> extends true ? [options: import('./types').EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: import('./types').EnforcedPathParamsOptions<TBody, TParams, Path> | undefined]) => import('./types').SchemaableResponse<unknown>;
+    patch: <Path extends string = string, TBody = unknown, TParams extends import('./types').RequestParamsType = import('./types').RequestParamsType>(url: Path, body?: TBody, ...args: [import('./utils').AssertSupportedPath<Path>] extends [never] ? [options: never] : import('./utils').HasRequiredParams<import('./utils').AssertSupportedPath<Path>> extends true ? [options: import('./types').EnforcedPathParamsOptions<TBody, TParams, Path>] : [options?: import('./types').EnforcedPathParamsOptions<TBody, TParams, Path> | undefined]) => import('./types').SchemaableResponse<unknown>;
+    delete: <Path extends string = string, TParams extends import('./types').RequestParamsType = import('./types').RequestParamsType>(url: Path, ...args: [import('./utils').AssertSupportedPath<Path>] extends [never] ? [options: never] : import('./utils').HasRequiredParams<import('./utils').AssertSupportedPath<Path>> extends true ? [options: import('./types').EnforcedPathParamsOptions<never, TParams, Path>] : [options?: import('./types').EnforcedPathParamsOptions<never, TParams, Path> | undefined]) => import('./types').SchemaableResponse<unknown>;
+    request: <Path extends string = string, TBody = unknown, TParams extends import('./types').RequestParamsType = import('./types').RequestParamsType>(url: Path, ...args: [import('./utils').AssertSupportedPath<Path>] extends [never] ? [options: never] : import('./utils').HasRequiredParams<import('./utils').AssertSupportedPath<Path>> extends true ? [options: import('./utils').RequirePathParams<import('./utils').AssertSupportedPath<Path>, string extends Path ? import('./core').HttpRequestOptions<TBody, TParams> : Omit<import('./core').HttpRequestOptions<TBody, TParams>, "pathParams">>] : [options?: import('./utils').RequirePathParams<import('./utils').AssertSupportedPath<Path>, string extends Path ? import('./core').HttpRequestOptions<TBody, TParams> : Omit<import('./core').HttpRequestOptions<TBody, TParams>, "pathParams">> | undefined]) => import('./types').SchemaableResponse<unknown>;
+};
+export default http;
+export { AsyncSchemaValidationError, HttpError, InvalidBaseUrlError, InvalidSchemaError, MiddlewareError, NetworkError, PathParameterError, SchemaValidationError, SerializationError, TimeoutError, } from './errors';
+export type { CustomFetch, DownloadStreamingEvent, EnforcedPathParamsOptions, ExtractableResponse, FetchOptions, HttpHeaders, HttpMethod, InferSchemaOutput, RequestContext, RequestOptions, RequestParamsType, ResponseType, RetryContext, RetryEvent, RetryJitter, RetryOptions, Schema, SchemaableResponse, SerializeBody, SerializeParams, UploadStreamingEvent, } from './types';
+export type { HttpClientConfig, HttpRequestOptions } from './core';
+export type { SchemaValidator } from './schema';

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{a,c as s,d as r,f as t,i as o,l as e,n as f,o as i,r as l,s as m,t as c,u as d}from"./client-DOv6m2TJ.mjs";var n=/* @__PURE__ */c();export{l as AsyncSchemaValidationError,o as HttpError,a as InvalidBaseUrlError,i as InvalidSchemaError,m as MiddlewareError,s as NetworkError,e as PathParameterError,d as SchemaValidationError,r as SerializationError,t as TimeoutError,c as createHttpClient,f as createSchemaValidator,n as default,n as http};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { createHttpClient } from './client'\n\nexport { createHttpClient } from './client'\nexport { createSchemaValidator } from './schema'\n\nexport const http = /* @__PURE__ */ createHttpClient()\nexport default http\n\nexport {\n  AsyncSchemaValidationError,\n  HttpError,\n  InvalidBaseUrlError,\n  InvalidSchemaError,\n  MiddlewareError,\n  NetworkError,\n  PathParameterError,\n  SchemaValidationError,\n  SerializationError,\n  TimeoutError,\n} from './errors'\n\nexport type {\n  CustomFetch,\n  DownloadStreamingEvent,\n  EnforcedPathParamsOptions,\n  ExtractableResponse,\n  FetchOptions,\n  HttpHeaders,\n  HttpMethod,\n  InferSchemaOutput,\n  RequestContext,\n  RequestOptions,\n  RequestParamsType,\n  ResponseType,\n  RetryContext,\n  RetryEvent,\n  RetryJitter,\n  RetryOptions,\n  Schema,\n  SchemaableResponse,\n  SerializeBody,\n  SerializeParams,\n  UploadStreamingEvent,\n} from './types'\n\nexport type { HttpClientConfig, HttpRequestOptions } from './core'\nexport type { SchemaValidator } from './schema'\n"],"mappings":"kHAKA,IAAa,iBAAuB"}

package/dist/schema.d.ts

@@ -0,0 +1,35 @@
+import { Schema } from './types';
+/**
+ * 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 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, synchronously or asynchronously
+     * @throws {SchemaValidationError} If the data doesn't match the schema
+     */
+    validate<T>(schema: Schema<T>, data: unknown): T | Promise<T>;
+}
+/**
+ * Create a default schema validator that supports Standard Schema.
+ *
+ * This validator works with schemas that implement the Standard Schema
+ * interface, including both synchronous and asynchronous validators.
+ *
+ * @returns A schema validator instance
+ *
+ * @example
+ * ```ts
+ * const validator = createSchemaValidator()
+ *
+ * const parsed = validator.validate(schema, data)
+ * ```
+ */
+export declare function createSchemaValidator(): SchemaValidator;

package/dist/types.d.ts

@@ -0,0 +1,145 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { AssertSupportedPath, RequirePathParams } from './utils';
+export type RetryJitter = 'none' | 'full' | 'equal' | ((delay: number, retryCount: number) => number);
+export interface RetryContext {
+    /** The error that may trigger a retry */
+    error: Error;
+    /** Zero-based retry count for the failed attempt */
+    retryCount: number;
+    /** HTTP method used for the request */
+    method: HttpMethod;
+    /** Final request URL after base URL, path params, middleware, and query params */
+    url: string;
+    /** Whether the serialized request body can be sent again safely */
+    bodyReplayable: boolean;
+}
+export interface RetryEvent extends RetryContext {
+    /** One-based attempt number that will run after the delay */
+    nextAttempt: number;
+    /** Delay before the next attempt in milliseconds */
+    delay: number;
+}
+export interface RetryOptions {
+    /** Maximum number of retry attempts when retries are enabled (default: 3) */
+    maxRetries?: number;
+    /** Base delay between retries in milliseconds when retries are enabled (default: 300) */
+    retryDelay?: number;
+    /** Exponential backoff factor (default: 2) */
+    backoffFactor?: number;
+    /** Status codes that should trigger a retry when retries are enabled (default: [408, 429, 500, 502, 503, 504]) */
+    retryStatusCodes?: number[];
+    /** Whether to retry on network errors when retries are enabled (default: true) */
+    retryNetworkErrors?: boolean;
+    /** Maximum retry delay in milliseconds when retries are enabled (default: 30_000) */
+    maxRetryDelay?: number;
+    /** Methods eligible for built-in retries when retries are enabled (default: idempotent methods) */
+    retryMethods?: readonly HttpMethod[];
+    /** Allows the built-in retry policy to retry methods outside retryMethods (default: false) */
+    retryUnsafeMethods?: boolean;
+    /** Applies jitter to calculated exponential backoff delays (default: 'none') */
+    jitter?: RetryJitter;
+    /** Whether to honor Retry-After response headers on HTTP errors (default: true) */
+    respectRetryAfter?: boolean;
+    /** Called before waiting for the next retry attempt */
+    onRetry?: (event: RetryEvent) => void | Promise<void>;
+    /** Custom function to determine if a request should be retried */
+    shouldRetry?: (error: Error, retryCount: number, context: RetryContext) => boolean | Promise<boolean>;
+}
+export type FetchOptions = Omit<RequestInit, 'body' | 'headers' | 'signal' | 'method'> & {
+    /** Node/undici and future Fetch extensions can be passed through here */
+    [option: string]: unknown;
+};
+export type EnforcedPathParamsOptions<TBody = unknown, TParams extends RequestParamsType = RequestParamsType, Path extends string = string> = RequirePathParams<AssertSupportedPath<Path>, string extends Path ? Omit<RequestOptions<TBody>, 'params'> & {
+    params?: TParams;
+} : Omit<RequestOptions<TBody>, 'params' | 'pathParams'> & {
+    params?: TParams;
+}>;
+export interface RequestOptions<TBody = unknown> {
+    headers?: HttpHeaders;
+    params?: RequestParamsType;
+    pathParams?: Record<string, string | number | undefined>;
+    body?: TBody;
+    timeout?: number;
+    signal?: AbortSignal;
+    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
+    cache?: RequestCache;
+    credentials?: RequestCredentials;
+    mode?: RequestMode;
+    redirect?: RequestRedirect;
+    fetchOptions?: FetchOptions;
+    retry?: RetryOptions | boolean;
+    onUploadStreaming?: (event: UploadStreamingEvent) => void;
+    onDownloadStreaming?: (event: DownloadStreamingEvent) => void;
+}
+export interface ResponseType<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: HttpHeaders;
+    method: HttpMethod;
+    url: string;
+    raw: Response;
+}
+export type ExtractableResponse<T> = Promise<ResponseType<T>> & {
+    data(): Promise<T>;
+    void(): Promise<void>;
+};
+export type SchemaableResponse<T> = ExtractableResponse<T> & {
+    schema<S extends Schema>(schema: S): ExtractableResponse<InferSchemaOutput<S>>;
+};
+/**
+ * Request context that can be modified by onRequest hook
+ */
+export 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: FetchOptions;
+}
+export interface ExtendedRequestInit extends RequestInit {
+    duplex?: 'half';
+}
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | (string & {});
+export type HttpHeaders = Record<string, string>;
+export type RequestParamsType = Record<string, string | number | boolean | (string | number | boolean | undefined | null)[] | undefined | null>;
+export type Schema<T = unknown> = StandardSchemaV1<unknown, T> | (StandardSchemaV1<unknown, T> & {
+    _output: T;
+}) | (StandardSchemaV1<unknown, T> & {
+    _output?: T;
+});
+export type InferSchemaOutput<ResponseSchema> = ResponseSchema extends unknown ? ResponseSchema extends {
+    parse: infer ParseFn;
+} ? ParseFn extends (...args: infer _Args) => infer Output ? Awaited<Output> : unknown : ResponseSchema extends {
+    _output: infer Output;
+} ? Output : ResponseSchema extends {
+    _output?: infer Output;
+} ? Output : ResponseSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ResponseSchema> : unknown : never;
+export interface UploadStreamingEvent {
+    /** Current data chunk being uploaded */
+    chunk: Uint8Array;
+    /** Total bytes to upload (from Content-Length header or body size) */
+    totalBytes: number | undefined;
+    /** Bytes already transferred */
+    transferredBytes: number;
+}
+export interface DownloadStreamingEvent {
+    /** Current data chunk being downloaded */
+    chunk: Uint8Array;
+    /** Total bytes to download (from Content-Length header, undefined if unknown) */
+    totalBytes: number | undefined;
+    /** Bytes already transferred */
+    transferredBytes: number;
+}
+export type SerializeBody<TBody = unknown> = (body: TBody) => BodyInit | null | undefined;
+export type SerializeParams = (params: RequestParamsType) => string;
+export type CustomFetch = typeof fetch;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { type AssertSupportedPath, generatePath, type HasRequiredParams, type PathParams, type RequirePathParams, } from './path';
+export { toStreamableRequest, toStreamableResponse } from './streaming';

package/dist/utils/path.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Strips protocol from URL (e.g., https://, http://)
+ */
+type StripProtocol<T extends string> = T extends `${string}://${infer After}` ? After : T;
+/**
+ * Strips host and optional port from URL, keeping only the path
+ * Handles cases like "localhost:3000/users" -> "/users"
+ */
+type StripHost<T extends string> = T extends `${infer _Host}/${infer Path}` ? `/${Path}` : T;
+/**
+ * Strips query string from path (e.g., "/users?x=1" -> "/users")
+ * Only strips ? that comes after the path, not ? that's part of path parameters
+ */
+type StripQuery<T extends string> = T extends `${infer Path}?${infer Query}` ? Query extends `${string}=${string}` | `${string}&${string}` | `${string}=${string}&${string}` ? Path : Query extends `/${string}` ? T : Query extends `` ? T : Path : T;
+/**
+ * Normalizes URL to path only, stripping protocol, host, port, and query
+ */
+type NormalizePath<T extends string> = StripQuery<StripHost<StripProtocol<T>>>;
+/**
+ * Removes optional suffix from param name (e.g., ":id?" -> "id", ":id" -> "id")
+ */
+type CleanParamName<S extends string> = S extends `:${infer Name}?` ? Name : S extends `:${infer Name}` ? Name : S;
+/**
+ * Extracts required path parameters from a route
+ */
+type ExtractRequiredRouteParams<T extends string> = NormalizePath<T> extends `${infer _Before}:${infer AfterColon}` ? AfterColon extends `${infer Param}/${infer Rest}` ? Param extends `${string}?` ? ExtractRequiredRouteParams<`/${Rest}`> : CleanParamName<`:${Param}`> | ExtractRequiredRouteParams<`/${Rest}`> : AfterColon extends `${string}?` ? never : CleanParamName<`:${AfterColon}`> : never;
+/**
+ * Extracts optional path parameters from a route
+ */
+type ExtractOptionalRouteParams<T extends string> = NormalizePath<T> extends `${infer _Before}:${infer AfterColon}` ? AfterColon extends `${infer Param}/${infer Rest}` ? (Param extends `${string}?` ? CleanParamName<`:${Param}`> : never) | ExtractOptionalRouteParams<`/${Rest}`> : AfterColon extends `${string}?` ? CleanParamName<`:${AfterColon}`> : never : never;
+type ExtractRouteParams<T extends string> = ExtractRequiredRouteParams<T> | ExtractOptionalRouteParams<T>;
+type HasNonTrailingOptionalRouteParams<T extends string> = string extends T ? false : NormalizePath<T> extends `${infer _Before}:${infer AfterColon}` ? AfterColon extends `${infer Param}/${infer Rest}` ? Param extends `${string}?` ? true : HasNonTrailingOptionalRouteParams<`/${Rest}`> : false : false;
+export type AssertSupportedPath<Path extends string> = string extends Path ? Path : HasNonTrailingOptionalRouteParams<Path> extends true ? never : Path;
+export type HasRequiredParams<T extends string> = [
+    ExtractRequiredRouteParams<T>
+] extends [never] ? false : true;
+type HasPathParams<T extends string> = [ExtractRouteParams<T>] extends [never] ? false : true;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * PathParams type - extracts parameter names and their types
+ */
+export type PathParams<Path extends string> = [
+    AssertSupportedPath<Path>
+] extends [never] ? never : Simplify<{
+    [K in ExtractRequiredRouteParams<Path>]: string | number;
+} & {
+    [K in ExtractOptionalRouteParams<Path>]?: string | number;
+}>;
+/**
+ * RequirePathParams enforces pathParams when needed
+ */
+export type RequirePathParams<Path extends string, T> = [
+    AssertSupportedPath<Path>
+] extends [never] ? never : HasRequiredParams<Path> extends true ? T & {
+    pathParams: PathParams<Path>;
+} : HasPathParams<Path> extends true ? T & {
+    pathParams?: PathParams<Path>;
+} : T;
+/**
+ * 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: AssertSupportedPath<Path>): string;
+export declare function generatePath<Path extends string>(path: AssertSupportedPath<Path>, params: PathParams<Path>): string;
+export {};

package/dist/utils/streaming.d.ts

@@ -0,0 +1,9 @@
+import { DownloadStreamingEvent, UploadStreamingEvent } from '../types';
+/**
+ * Creates a request with upload streaming tracking
+ */
+export declare function toStreamableRequest(request: Request, onUploadStreaming?: (event: UploadStreamingEvent) => void): Promise<Request>;
+/**
+ * Creates a response with download streaming tracking
+ */
+export declare function toStreamableResponse(response: Response, onDownloadStreaming?: (event: DownloadStreamingEvent) => void): Promise<Response>;