1000fetches 0.1.0

package/dist/index.es.js

@@ -0,0 +1,918 @@
+class HttpError extends Error {
+  name = "HttpError";
+  status;
+  statusText;
+  data;
+  response;
+  url;
+  method;
+  cause;
+  constructor(message, status, statusText, data, response, url, method, cause) {
+    const enhancedMessage = `HTTP ${status} ${statusText}: ${message} (${method} ${url})`;
+    super(enhancedMessage, { cause });
+    this.status = status;
+    this.statusText = statusText;
+    this.data = data;
+    this.response = response;
+    this.url = url;
+    this.method = method;
+  }
+}
+class NetworkError extends Error {
+  name = "NetworkError";
+  cause;
+  constructor(message, cause) {
+    super(message, { cause });
+  }
+}
+class SchemaValidationError extends Error {
+  name = "SchemaValidationError";
+  schema;
+  data;
+  cause;
+  constructor(message, schema, data, cause) {
+    super(message, { cause });
+    this.schema = schema;
+    this.data = data;
+  }
+}
+class TimeoutError extends Error {
+  name = "TimeoutError";
+  cause;
+  constructor(message, cause) {
+    super(message, { cause });
+  }
+}
+class PathParameterError extends Error {
+  name = "PathParameterError";
+  url;
+  requiredParams;
+  providedParams;
+  cause;
+  constructor(message, url, requiredParams, providedParams, cause) {
+    super(message, { cause });
+    this.url = url;
+    this.requiredParams = requiredParams;
+    this.providedParams = providedParams;
+  }
+}
+class InterceptorError extends Error {
+  name = "InterceptorError";
+  interceptorType;
+  url;
+  method;
+  cause;
+  constructor(message, interceptorType, url, method, cause) {
+    super(message, { cause });
+    this.interceptorType = interceptorType;
+    this.url = url;
+    this.method = method;
+  }
+}
+class SerializationError extends Error {
+  name = "SerializationError";
+  cause;
+  constructor(message, cause) {
+    super(message, { cause });
+  }
+}
+function isStandardSchema(obj) {
+  return obj !== null && (typeof obj === "object" || typeof obj === "function") && "~standard" in obj && typeof obj["~standard"] === "object" && obj["~standard"] !== null && "validate" in obj["~standard"] && typeof obj["~standard"].validate === "function" && "version" in obj["~standard"] && typeof obj["~standard"].version === "number" && "vendor" in obj["~standard"] && typeof obj["~standard"].vendor === "string";
+}
+function standardSchemaAdapter(schema) {
+  return {
+    /**
+     * 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) => {
+      const result = schema["~standard"].validate(data);
+      if (result instanceof Promise) {
+        throw new Error("Async Standard Schema validation is not supported");
+      }
+      if ("issues" in result && result.issues) {
+        const errorMessages = Array.from(result.issues).map((issue) => issue.message).join("; ");
+        throw new Error(`Standard Schema validation failed: ${errorMessages}`);
+      }
+      return result.value;
+    }
+  };
+}
+function createStandardSchemaValidator() {
+  return {
+    /**
+     * Validates data against a Standard Schema V1 implementation
+     *
+     * @param schema - The Standard Schema V1 to validate against
+     * @param data - The data to validate
+     * @returns The validated and typed data
+     * @throws Error if validation fails or schema is invalid
+     */
+    validate(schema, data) {
+      if (!isStandardSchema(schema)) {
+        throw new Error(
+          "Invalid schema: Schema must implement the Standard Schema interface"
+        );
+      }
+      const adapter = standardSchemaAdapter(schema);
+      return adapter.parse(data);
+    },
+    /**
+     * Checks if an object is a valid Standard Schema V1 implementation
+     *
+     * @param obj - The object to check
+     * @returns True if the object is a valid Standard Schema V1
+     */
+    isSchema(obj) {
+      return isStandardSchema(obj);
+    }
+  };
+}
+function createSchemaValidator() {
+  return {
+    validate(schema, data) {
+      if (!isStandardSchema(schema)) {
+        throw new Error(
+          "Invalid schema: Schema must implement the Standard Schema interface"
+        );
+      }
+      return createStandardSchemaValidator().validate(schema, data);
+    },
+    isSchema(obj) {
+      return isStandardSchema(obj);
+    }
+  };
+}
+function generatePath(path, params = {}) {
+  return path.replace(/:([a-zA-Z0-9_]+)/g, (_match, paramName) => {
+    if (params[paramName] === void 0) {
+      throw new PathParameterError(
+        `Missing required path parameter: ${paramName}`,
+        path,
+        [paramName],
+        Object.keys(params)
+      );
+    }
+    return String(params[paramName]);
+  });
+}
+const DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  retryDelay: 300,
+  backoffFactor: 2,
+  retryStatusCodes: [429, 500, 502, 503, 504],
+  retryNetworkErrors: true,
+  maxRetryDelay: 3e4,
+  shouldRetry: () => true
+};
+function validateAndNormalizeBaseUrl(baseUrl) {
+  if (!baseUrl) {
+    return "";
+  }
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new Error(`Invalid baseUrl: "${baseUrl}". Must be a valid URL.`);
+  }
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+class HttpClient {
+  baseUrl;
+  defaultHeaders;
+  defaultTimeout;
+  schemaValidator;
+  requestInterceptors;
+  responseInterceptors;
+  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 = {}) {
+    this.baseUrl = validateAndNormalizeBaseUrl(options.baseUrl);
+    this.defaultHeaders = options.headers || {};
+    this.defaultTimeout = options.timeout || 3e4;
+    this.schemaValidator = options.schemaValidator || createSchemaValidator();
+    this.requestInterceptors = options.requestInterceptors || [];
+    this.responseInterceptors = options.responseInterceptors || [];
+    this.defaultRetryOptions = options.retryOptions;
+  }
+  /**
+   * 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) {
+    this.requestInterceptors.push(interceptor);
+  }
+  /**
+   * 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) {
+    this.responseInterceptors.push(interceptor);
+  }
+  /**
+   * 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) {
+    this.schemaValidator = validator;
+  }
+  /**
+   * 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
+   */
+  async shouldRetry(error, retryCount, retryOptions) {
+    if (retryOptions === false) return false;
+    const options = this.getRetryOptions(retryOptions);
+    if (retryCount >= options.maxRetries) return false;
+    if (typeof options.shouldRetry === "function") {
+      try {
+        return await options.shouldRetry(error, retryCount);
+      } catch (retryError) {
+        console.warn("Custom shouldRetry function failed:", retryError);
+      }
+    }
+    if (error instanceof NetworkError && options.retryNetworkErrors) {
+      return true;
+    }
+    if (error instanceof HttpError && options.retryStatusCodes.includes(error.status)) {
+      return true;
+    }
+    if (error instanceof SchemaValidationError) {
+      return false;
+    }
+    if (error instanceof TimeoutError) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 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
+   */
+  getRetryDelay(retryCount, options) {
+    const baseDelay = options.retryDelay * Math.pow(options.backoffFactor, retryCount);
+    const cappedDelay = Math.min(baseDelay, options.maxRetryDelay);
+    const jitterRange = cappedDelay * 0.2;
+    const jitter = jitterRange * (Math.random() * 2 - 1);
+    const finalDelay = cappedDelay + jitter;
+    return Math.max(1, Math.floor(finalDelay));
+  }
+  /**
+   * Merges provided retry options with default configuration
+   *
+   * @param retryOptions - Retry options to merge with defaults
+   * @returns Complete retry configuration with all required properties
+   */
+  getRetryOptions(retryOptions) {
+    if (retryOptions === false) {
+      return {
+        ...DEFAULT_RETRY_OPTIONS,
+        maxRetries: 0
+      };
+    }
+    if (retryOptions === true) {
+      return {
+        ...DEFAULT_RETRY_OPTIONS,
+        ...this.defaultRetryOptions
+      };
+    }
+    if (typeof retryOptions === "object") {
+      return {
+        ...DEFAULT_RETRY_OPTIONS,
+        ...this.defaultRetryOptions,
+        ...retryOptions
+      };
+    }
+    return {
+      ...DEFAULT_RETRY_OPTIONS,
+      ...this.defaultRetryOptions
+    };
+  }
+  /**
+   * Creates a promise that resolves after the specified delay
+   *
+   * @param ms - Delay duration in milliseconds
+   * @returns Promise that resolves after the delay
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 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
+   * });
+   * ```
+   */
+  async request(method, url, options = {}) {
+    let retryCount = 0;
+    while (true) {
+      try {
+        return await this.executeRequest(
+          method,
+          url,
+          options
+        );
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw new NetworkError(String(error), void 0);
+        }
+        if (await this.shouldRetry(error, retryCount, options.retry)) {
+          const retryOptions = this.getRetryOptions(options.retry);
+          const delay = this.getRetryDelay(retryCount, retryOptions);
+          await this.sleep(delay);
+          retryCount++;
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  /**
+   * 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
+   */
+  async executeRequest(method, url, options = {}) {
+    let resolvedUrl = this.resolveUrl(url, options.pathParams);
+    let requestContext = {
+      url: resolvedUrl,
+      method,
+      params: options.params,
+      headers: this.prepareHeaders(options.headers),
+      body: options.body,
+      fetchOptions: {
+        credentials: options.credentials,
+        cache: options.cache,
+        mode: options.mode,
+        redirect: options.redirect
+      }
+    };
+    for (const interceptor of this.requestInterceptors) {
+      try {
+        requestContext = await interceptor(requestContext);
+      } catch (error) {
+        throw new InterceptorError(
+          `Request interceptor failed: ${error instanceof Error ? error.message : String(error)}`,
+          "request",
+          resolvedUrl,
+          method,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+    resolvedUrl = requestContext.url;
+    if (requestContext.params && Object.keys(requestContext.params).length > 0) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(requestContext.params)) {
+        if (value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      }
+      const queryString = searchParams.toString();
+      if (queryString) {
+        resolvedUrl += (resolvedUrl.includes("?") ? "&" : "?") + queryString;
+      }
+    }
+    const requestInit = {
+      method: requestContext.method,
+      headers: requestContext.headers,
+      ...requestContext.fetchOptions
+    };
+    if (requestContext.body !== void 0 && (requestContext.method === "POST" || requestContext.method === "PUT" || requestContext.method === "PATCH")) {
+      if (requestContext.body instanceof FormData || requestContext.body instanceof Blob || requestContext.body instanceof ArrayBuffer || requestContext.body instanceof URLSearchParams || typeof requestContext.body === "string") {
+        requestInit.body = requestContext.body;
+      } else {
+        try {
+          requestInit.body = JSON.stringify(requestContext.body);
+        } catch (error) {
+          throw new SerializationError(
+            `Failed to serialize request body: ${error instanceof Error ? error.message : "Invalid data structure"}`,
+            error instanceof Error ? error : void 0
+          );
+        }
+      }
+    }
+    const timeoutDuration = options.timeout || this.defaultTimeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutDuration);
+    const requestSignal = requestContext.signal || options.signal;
+    let cleanupSignals;
+    const signal = requestSignal ? (() => {
+      const result = this.mergeAbortSignals(
+        requestSignal,
+        controller.signal
+      );
+      cleanupSignals = result.cleanup;
+      return result.signal;
+    })() : controller.signal;
+    try {
+      const response = await fetch(resolvedUrl, {
+        ...requestInit,
+        signal
+      });
+      let responseData = await this.processResponse(
+        response,
+        options,
+        method,
+        resolvedUrl
+      );
+      if (options.schema) {
+        responseData.data = this.validateResponseData(
+          options.schema,
+          responseData.data
+        );
+      }
+      return responseData;
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError" || error instanceof Error && error.message.toLowerCase().includes("timeout")) {
+        throw new TimeoutError(
+          `Request timed out after ${timeoutDuration}ms`,
+          error instanceof Error ? error : void 0
+        );
+      }
+      if (error instanceof HttpError || error instanceof SchemaValidationError || error instanceof InterceptorError || error instanceof PathParameterError || error instanceof SerializationError) {
+        throw error;
+      }
+      throw new NetworkError(
+        error instanceof Error ? error.message : String(error),
+        error instanceof Error ? error : void 0
+      );
+    } finally {
+      clearTimeout(timeoutId);
+      cleanupSignals?.();
+    }
+  }
+  validateWithSchema(schema, data, errorPrefix) {
+    try {
+      return this.schemaValidator.validate(schema, data);
+    } catch (error) {
+      throw new SchemaValidationError(
+        `${errorPrefix}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        schema,
+        data,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  validateResponseData(schema, data) {
+    return this.validateWithSchema(
+      schema,
+      data,
+      "Response schema validation failed"
+    );
+  }
+  /**
+   * 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(schema, data) {
+    return this.validateWithSchema(schema, data, "Schema validation failed");
+  }
+  /**
+   * 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
+   */
+  prepareHeaders(customHeaders = {}) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(this.defaultHeaders)) {
+      if (value != null) {
+        headers.set(key, String(value));
+      }
+    }
+    for (const [key, value] of Object.entries(customHeaders)) {
+      if (value != null) {
+        headers.set(key, String(value));
+      }
+    }
+    return headers;
+  }
+  /**
+   * Extracts headers from Headers object into a plain record
+   *
+   * @param headers - Headers object to extract from
+   * @returns Record containing header key-value pairs
+   */
+  extractHeaders(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  /**
+   * 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
+   */
+  createHttpError(response, data, url, method, customStatusText, cause) {
+    return new HttpError(
+      `Request failed with status code ${response.status}`,
+      response.status,
+      customStatusText || response.statusText,
+      data,
+      response,
+      url,
+      method,
+      cause
+    );
+  }
+  async parseResponseBody(response, options) {
+    const contentType = response.headers.get("content-type") ?? "";
+    try {
+      if (options.responseType === "text") {
+        return await response.text();
+      } else if (options.responseType === "blob") {
+        return await response.blob();
+      } else if (options.responseType === "arrayBuffer") {
+        return await response.arrayBuffer();
+      } else if (contentType.includes("application/json")) {
+        const text = await response.text();
+        if (!text) {
+          return null;
+        }
+        return JSON.parse(text);
+      } else {
+        return await response.text();
+      }
+    } catch (e) {
+      if (response.status === 204) {
+        return void 0;
+      }
+      if (contentType.includes("application/json") && e instanceof SyntaxError) {
+        throw new Error(`Failed to parse JSON response: ${e.message}`);
+      }
+      throw e;
+    }
+  }
+  async processResponse(response, options, method, url) {
+    const headers = this.extractHeaders(response.headers);
+    const validateStatus = options.validateStatus || ((status) => status >= 200 && status < 300);
+    const data = await this.parseResponseBody(response, options);
+    if (!validateStatus(response.status)) {
+      throw this.createHttpError(response, data, url, method);
+    }
+    const responseObj = {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      method,
+      url,
+      raw: response
+    };
+    let processedResponse = responseObj;
+    const originalStatus = responseObj.status;
+    for (const interceptor of this.responseInterceptors) {
+      try {
+        processedResponse = await interceptor(processedResponse);
+      } catch (error) {
+        throw new InterceptorError(
+          `Response interceptor failed: ${error instanceof Error ? error.message : String(error)}`,
+          "response",
+          url,
+          method,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+    if (processedResponse.status !== originalStatus && !validateStatus(processedResponse.status)) {
+      throw this.createHttpError(
+        response,
+        processedResponse.data,
+        url,
+        method,
+        processedResponse.statusText
+      );
+    }
+    return processedResponse;
+  }
+  mergeAbortSignals(signal1, signal2) {
+    if (signal1.aborted || signal2.aborted) {
+      const controller2 = new AbortController();
+      controller2.abort();
+      return { signal: controller2.signal };
+    }
+    const controller = new AbortController();
+    const abortHandler = () => {
+      controller.abort();
+      cleanup();
+    };
+    const cleanup = () => {
+      signal1.removeEventListener("abort", abortHandler);
+      signal2.removeEventListener("abort", abortHandler);
+    };
+    signal1.addEventListener("abort", abortHandler);
+    signal2.addEventListener("abort", abortHandler);
+    return { signal: controller.signal, cleanup };
+  }
+  get(url, options) {
+    return this.request(
+      "GET",
+      url,
+      options || {}
+    );
+  }
+  post(url, body, options) {
+    return this.request("POST", url, {
+      ...options || {},
+      body
+    });
+  }
+  put(url, body, options) {
+    return this.request("PUT", url, {
+      ...options || {},
+      body
+    });
+  }
+  patch(url, body, options) {
+    return this.request("PATCH", url, {
+      ...options || {},
+      body
+    });
+  }
+  delete(url, options) {
+    return this.request(
+      "DELETE",
+      url,
+      options || {}
+    );
+  }
+  /**
+   * 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
+   */
+  validatePathParams(url, pathParams) {
+    if (!pathParams) {
+      const requiredParams2 = this.extractRequiredPathParams(url);
+      if (requiredParams2.length > 0) {
+        throw new PathParameterError(
+          `Missing required path parameters for URL "${url}": ${requiredParams2.join(", ")}. Please provide pathParams: { ${requiredParams2.map((p) => `${p}: value`).join(", ")} }`,
+          url,
+          requiredParams2,
+          []
+        );
+      }
+      return;
+    }
+    const requiredParams = this.extractRequiredPathParams(url);
+    const providedParams = Object.keys(pathParams);
+    const missingParams = requiredParams.filter(
+      (param) => !providedParams.includes(param)
+    );
+    if (missingParams.length > 0) {
+      throw new PathParameterError(
+        `Missing required path parameters: ${missingParams.join(", ")}. Provided: ${providedParams.join(", ")}`,
+        url,
+        requiredParams,
+        providedParams
+      );
+    }
+  }
+  /**
+   * Extracts required path parameters from a URL template
+   *
+   * @param url - URL template to extract parameters from
+   * @returns Array of required parameter names
+   */
+  extractRequiredPathParams(url) {
+    const matches = url.match(/:([a-zA-Z0-9_]+)/g);
+    if (!matches) return [];
+    return matches.map((match) => match.slice(1));
+  }
+  /**
+   * 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
+   */
+  resolveUrl(url, pathParams) {
+    this.validatePathParams(url, pathParams);
+    const interpolatedUrl = pathParams ? generatePath(url, pathParams) : url;
+    if (/^https?:\/\//i.test(interpolatedUrl)) {
+      return interpolatedUrl;
+    }
+    const path = interpolatedUrl.startsWith("/") ? interpolatedUrl.slice(1) : interpolatedUrl;
+    return `${this.baseUrl}/${path}`;
+  }
+}
+export {
+  HttpClient,
+  HttpError,
+  InterceptorError,
+  NetworkError,
+  PathParameterError,
+  SchemaValidationError,
+  TimeoutError,
+  createSchemaValidator,
+  createStandardSchemaValidator,
+  generatePath,
+  isStandardSchema,
+  standardSchemaAdapter
+};
+//# sourceMappingURL=index.es.js.map