@faasjs/react 8.0.0-beta.28 → 8.0.0-beta.29

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { Component, ComponentProps, ComponentType, Dispatch, ErrorInfo, JSX, Rea
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { FaasAction, FaasAction as FaasAction$1, FaasActionUnionType, FaasActionUnionType as FaasActionUnionType$1, FaasData, FaasData as FaasData$1, FaasParams, FaasParams as FaasParams$1 } from "@faasjs/types";
 
-//#region src/generateId/index.d.ts
+//#region src/generate-id/index.d.ts
 /**
  * Generate a random identifier with an optional prefix.
  *
@@ -23,169 +23,7 @@ import { FaasAction, FaasAction as FaasAction$1, FaasActionUnionType, FaasAction
  */
 declare function generateId(prefix?: string, length?: number): string;
 //#endregion
-//#region src/browser/index.d.ts
-/**
- * Template literal type for URL strings that must end with a forward slash.
- *
- * Ensures that base URLs used in FaasJS requests always have a trailing '/' character,
- * which is required for proper URL construction when appending action paths.
- *
- * Notes:
- * - Type only accepts strings ending with '/' (e.g., 'https://api.example.com/', '/')
- * - Strings without trailing '/' will fail TypeScript type checking
- * - Used by FaasBrowserClient constructor and Options type
- * - Ensures consistent URL formatting across the codebase
- * - Throws Error at runtime if baseUrl doesn't end with '/'
- *
- * @see {@link FaasBrowserClient} for usage in client creation.
- * @see {@link Options} for usage in request options.
- */
-type BaseUrl = `${string}/`;
-/**
- * Configuration options for FaasJS requests.
- *
- * Extends the standard RequestInit interface with FaasJS-specific options for
- * customizing request behavior, adding request hooks, and overriding defaults.
- *
- * Notes:
- * - Options can be provided at client creation (defaultOptions) or per-request
- * - Per-request options override client default options
- * - headers are merged: per-request headers override default headers
- * - beforeRequest hook is called before the request is sent, allowing modification
- * - Custom request function completely replaces the default fetch implementation
- * - baseUrl in options overrides the client's baseUrl for this specific request
- * - When stream is true, returns the native fetch Response instead of wrapped Response
- *
- * @property {Record<string, string>} [headers] - Default headers to include in all requests.
- *   Merged with client default headers, with per-request headers taking precedence.
- *   Common headers include Content-Type, Authorization, and custom application headers.
- *
- * @property {Function} [beforeRequest] - Async hook called before sending each request.
- *   Receives action, params, options, and headers, allowing modification before the request is sent.
- *   Useful for logging, authentication, adding timestamps, or modifying headers dynamically.
- *   Any changes to the headers object will affect the actual request.
- *
- * @property {Function} [request] - Custom request function to replace the default fetch.
- *   Allows using alternative HTTP clients like axios, XMLHttpRequest, or custom implementations.
- *   Receives the URL and parsed options, must return a Promise resolving to a Response object.
- *   When provided, this function is used instead of the native fetch API.
- *
- * @property {BaseUrl} [baseUrl] - Optional override for the base URL for this specific request.
- *   If provided, overrides the client's baseUrl. Must end with '/'.
- *   Useful for making requests to different endpoints or environments from the same client instance.
- *
- * @property {boolean} [stream] - Enable streaming mode for large responses.
- *   When true, returns the raw fetch Response object instead of a wrapped Response.
- *   Useful for processing large data incrementally or working with binary data streams.
- *   When false or undefined, returns a wrapped Response with automatic JSON parsing.
- *
- * @augments RequestInit
- * @see {@link FaasBrowserClient} for client creation.
- * @see {@link Response} for response object structure.
- */
-type Options = RequestInit & {
-  headers?: Record<string, string>; /** Async hook called after request options are merged but before the request is sent. */
-  beforeRequest?: ({
-    action,
-    params,
-    options,
-    headers
-  }: {
-    action: string;
-    params?: Record<string, any> | undefined;
-    options: Options;
-    headers: Record<string, string>;
-  }) => Promise<void>; /** Custom request implementation used instead of the native `fetch`. */
-  request?: <PathOrData extends FaasActionUnionType$1>(url: string, options: Options) => Promise<Response<FaasData$1<PathOrData>>>; /** Base URL override for the current request. */
-  baseUrl?: BaseUrl; /** When `true`, return the native fetch response so callers can consume the stream manually. */
-  stream?: boolean;
-};
-/**
- * Simple key-value object for HTTP response headers.
- *
- * Represents headers as a plain object with string keys and string values.
- * Used by Response, ResponseError, and Options types.
- *
- * @property {string} [key] - Dynamic string keys for header names (e.g., 'Content-Type', 'Authorization').
- *   Values must be strings. Multiple values for the same key are not supported.
- *
- * Notes:
- * - Headers are case-insensitive in HTTP but stored with exact casing in this object
- * - Common headers include: Content-Type, Authorization, x-faasjs-request-id, X-Custom-Header
- * - No support for multi-value headers (use comma-separated values instead)
- * - Used in Response, ResponseError, and Options types
- * - Simplified model compared to browser's Headers interface (no .get(), .set() methods)
- *
- * @see {@link Response} for usage in response objects.
- * @see {@link ResponseError} for usage in error objects.
- * @see {@link Options} for usage in request options.
- */
-type ResponseHeaders = {
-  [key: string]: string;
-};
-/**
- * Type definition for the FaasBrowserClient.action method.
- *
- * Defines the signature of the method used to make requests to FaasJS functions.
- * Provides type-safe parameter and return value handling.
- *
- * @template PathOrData - The function path or data type for type safety
- *
- * @param {FaasAction<PathOrData>} action - The function path to call.
- * @param {FaasParams<PathOrData>} [params] - Optional parameters for the function.
- * @param {Options} [options] - Optional request overrides.
- * See {@link Options} for supported request fields such as `headers`, `beforeRequest`,
- * `request`, `baseUrl`, and `stream`.
- * @returns {Promise<Response<FaasData<PathOrData>> | Response>} Promise resolving to the request response. In streaming mode the runtime returns the native fetch response.
- *
- * Notes:
- * - Used internally by FaasBrowserClient.action method
- * - Provides type-safe action method signature
- * - Return type includes both typed and untyped Response variants
- * - Params are optional and can be undefined
- * - Options override client defaults when provided
- *
- * @see {@link FaasBrowserClient} for the class that uses this type.
- * @see {@link Response} for the return type.
- * @see {@link Options} for the options parameter type.
- */
-type FaasBrowserClientAction = <PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, params?: FaasParams$1<PathOrData>, options?: Options) => Promise<Response<FaasData$1<PathOrData>> | Response>;
-/**
- * Properties for creating a Response object.
- *
- * Defines the structure of response data that can be passed to the Response constructor
- * or returned from mock handlers.
- *
- * @template T - The type of the data property for type-safe response creation
- *
- * @property {number} [status] - The HTTP status code for the response.
- *   Optional: defaults to 200 if data or body is provided, 204 otherwise.
- *
- * @property {ResponseHeaders} [headers] - The response headers as a key-value object.
- *   Optional: defaults to an empty object if not provided.
- *
- * @property {any} [body] - The raw response body as a string or object.
- *   Optional: if not provided, body is automatically populated from data using JSON.stringify.
- *
- * @property {T} [data] - The parsed JSON data to include in the response.
- *   Optional: contains the response payload when JSON data is provided.
- *
- * Notes:
- * - All properties are optional
- * - At least one of data or body should be provided for meaningful responses
- * - The Response class automatically defaults status to 200 or 204 based on content
- * - If data is provided without body, body is automatically JSON.stringify(data)
- * - Used by Response constructor and mock handlers
- *
- * @see {@link Response} for the class that uses these properties.
- * @see {@link ResponseErrorProps} for error response properties.
- */
-type ResponseProps<T = any> = {
-  status?: number;
-  headers?: ResponseHeaders;
-  body?: any;
-  data?: T;
-};
+//#region src/browser/response.d.ts
 /**
  * Wrapper class for HTTP responses from FaasJS functions.
  *
@@ -193,113 +31,6 @@ type ResponseProps<T = any> = {
  * body, and parsed data. Automatically handles JSON serialization and status code defaults.
  *
  * @template T - The type of the data property for type-safe response handling
- *
- * @property {number} status - The HTTP status code of the response.
- *   Defaults to 200 if data or body is provided, 204 if neither is present.
- * @property {ResponseHeaders} headers - The response headers as a key-value object.
- *   Empty object if no headers were provided.
- * @property {any} body - The raw response body as a string or object.
- *   If data is provided without body, body is automatically set to JSON.stringify(data).
- * @property {T} [data] - The parsed JSON data from the response.
- *   Optional property that contains the response payload when JSON is provided.
- *
- * Notes:
- * - status defaults to 200 if data or body is present, 204 otherwise
- * - body is automatically populated from data if not explicitly provided
- * - headers defaults to an empty object if not provided
- * - Use generic type parameter T for type-safe data access
- * - Commonly used as the return type from client.action() method
- * - Can be used in mock handlers to return structured responses
- * - The data property is optional and may be undefined for responses without data
- *
- * @example Create successful response with data
- * ```ts
- * const response = new Response({
- *   status: 200,
- *   data: {
- *     id: 123,
- *     name: 'John Doe'
- *   }
- * })
- * console.log(response.status) // 200
- * console.log(response.data.name) // 'John Doe'
- * ```
- *
- * @example Create response with type safety
- * ```ts
- * interface User {
- *   id: number
- *   name: string
- *   email: string
- * }
- *
- * const response = new Response<User>({
- *   data: {
- *     id: 123,
- *     name: 'John',
- *     email: 'john@example.com'
- *   }
- * })
- * // TypeScript knows response.data.name is a string
- * ```
- *
- * @example Create response with headers
- * ```ts
- * const response = new Response({
- *   status: 201,
- *   data: { created: true },
- *   headers: {
- *     'Content-Type': 'application/json',
- *     'x-faasjs-request-id': 'req-123',
- *     'X-Cache-Key': 'user-123'
- *   }
- * })
- * ```
- *
- * @example Create response with custom body
- * ```ts
- * const response = new Response({
- *   status: 200,
- *   body: JSON.stringify({ custom: 'format' }),
- *   headers: { 'Content-Type': 'application/json' }
- * })
- * ```
- *
- * @example Create empty response (204 No Content)
- * ```ts
- * const response = new Response()
- * // status: 204, headers: {}, body: undefined, data: undefined
- * ```
- *
- * @example Create error response
- * ```ts
- * const response = new Response({
- *   status: 404,
- *   data: {
- *     error: {
- *       message: 'User not found',
- *       code: 'USER_NOT_FOUND'
- *     }
- *   }
- * })
- * ```
- *
- * @example Use in mock handler
- * ```ts
- * setMock(async (action, params) => {
- *   if (action === 'user') {
- *     return new Response({
- *       status: 200,
- *       data: { id: params.id, name: 'Mock User' }
- *     })
- *   }
- *   return new Response({ status: 404, data: { error: 'Not found' } })
- * })
- * ```
- *
- * @see {@link ResponseProps} for response property type.
- * @see {@link ResponseError} for error response handling.
- * @see {@link FaasBrowserClient.action} for method returning Response.
  */
 declare class Response<T = any> {
   /**
@@ -320,121 +51,14 @@ declare class Response<T = any> {
   readonly data?: T;
   /**
    * Create a wrapped response object.
-   *
-   * @param {ResponseProps<T>} [props] - Response properties including status, headers, body, and data.
-   * @param {number} [props.status] - HTTP status code. Defaults to `200` when `data` or `body` exists, otherwise `204`.
-   * @param {ResponseHeaders} [props.headers] - Response headers keyed by header name.
-   * @param {any} [props.body] - Raw response body to expose without additional parsing.
-   * @param {T} [props.data] - Parsed response payload to expose on `response.data`.
-   * @returns {Response<T>} Wrapped response instance.
    */
   constructor(props?: ResponseProps<T>);
 }
-/**
- * Input accepted by the {@link ResponseError} constructor.
- */
-type ResponseErrorProps = {
-  /** User-facing error message. */message: string; /** HTTP status code reported for the error. @default 500 */
-  status?: number; /** Response headers returned with the error. @default {} */
-  headers?: ResponseHeaders; /** Raw error body or structured error payload. @default { error: { message } } */
-  body?: any; /** Original error preserved when this instance wraps another exception. */
-  originalError?: Error;
-};
 /**
  * Custom error class for handling HTTP response errors from FaasJS requests.
  *
  * Extends the built-in Error class to provide additional information about failed requests,
  * including HTTP status code, response headers, response body, and the original error.
- *
- * @augments Error
- *
- * @property {number} status - The HTTP status code of the failed response. Defaults to 500 if not provided.
- * @property {ResponseHeaders} headers - The response headers from the failed request.
- * @property {any} body - The response body containing error details or the original error if available.
- * @property {Error} [originalError] - The original Error object if this ResponseError was created from another Error.
- *
- * @example Basic error with message
- * ```ts
- * throw new ResponseError('User not found')
- * // or inside action method:
- * catch (error) {
- *   throw new ResponseError(error.message)
- * }
- * ```
- *
- * @example Error from existing Error
- * ```ts
- * try {
- *   await someOperation()
- * } catch (error) {
- *   throw new ResponseError(error, {
- *     status: 500,
- *     headers: { 'X-Error-Type': 'internal' }
- *   })
- * }
- * ```
- *
- * @example Error with complete response details
- * ```ts
- * throw new ResponseError({
- *   message: 'Validation failed',
- *   status: 400,
- *   headers: { 'X-Error-Code': 'VALIDATION_ERROR' },
- *   body: {
- *     error: {
- *       message: 'Validation failed',
- *       fields: ['email', 'password']
- *     }
- *   }
- * })
- * ```
- *
- * @example Handling ResponseError in client
- * ```ts
- * try {
- *   const response = await client.action('user', { id: 123 })
- *   console.log(response.data)
- * } catch (error) {
- *   if (error instanceof ResponseError) {
- *     console.error(`Request failed: ${error.message}`)
- *     console.error(`Status: ${error.status}`)
- *     if (error.body) {
- *       console.error('Error details:', error.body)
- *     }
- *     if (error.headers['x-faasjs-request-id']) {
- *       console.error('Request ID:', error.headers['x-faasjs-request-id'])
- *     }
- *   }
- * }
- * ```
- *
- * @example Throwing ResponseError from mock
- * ```ts
- * setMock(async (action, params) => {
- *   if (action === 'login') {
- *     if (!params.email || !params.password) {
- *       throw new ResponseError({
- *         message: 'Email and password are required',
- *         status: 400,
- *         body: { error: 'missing_fields' }
- *       })
- *     }
- *     return { data: { token: 'abc123' } }
- *   }
- * })
- * ```
- *
- * Notes:
- * - ResponseError is automatically thrown by the action method when the server returns an error (status >= 400)
- * - The error message from server responses is extracted from body.error.message if available
- * - When created from an Error object, the original error is preserved in the originalError property
- * - The status property defaults to 500 if not explicitly provided
- * - Use instanceof ResponseError to distinguish FaasJS errors from other JavaScript errors
- * - The body property can contain structured error information from the server response
- *
- * @see {@link FaasBrowserClient.action} for how ResponseError is thrown in requests.
- * @see {@link ResponseProps} for the structure of response data.
- * @see {@link setMock} for mocking errors in tests.
  */
 declare class ResponseError extends Error {
   /**
@@ -455,219 +79,82 @@ declare class ResponseError extends Error {
   readonly originalError?: Error;
   /**
    * Create a ResponseError from a message, Error, or structured response error payload.
-   *
-   * @param {string | Error | ResponseErrorProps} data - Error message, Error object, or structured response error props.
-   * @param {string} data.message - User-facing error message when `data` is a structured object.
-   * @param {number} [data.status] - HTTP status code when `data` is a structured object.
-   * @param {ResponseHeaders} [data.headers] - Response headers returned with the error when `data` is a structured object.
-   * @param {any} [data.body] - Raw error body or structured error payload when `data` is a structured object.
-   * @param {Error} [data.originalError] - Original error preserved on the instance when `data` is a structured object.
-   * @param {Omit<ResponseErrorProps, 'message' | 'originalError'>} [options] - Additional options such as status, headers, and body.
-   * @param {number} [options.status] - HTTP status override used when `data` is a string or `Error`.
-   * @param {ResponseHeaders} [options.headers] - Response headers override used when `data` is a string or `Error`.
-   * @param {any} [options.body] - Raw error body override used when `data` is a string or `Error`.
-   * @returns {ResponseError} ResponseError instance.
    */
   constructor(data: string | Error, options?: Omit<ResponseErrorProps, 'message' | 'originalError'>);
   constructor(data: ResponseErrorProps);
 }
+//#endregion
+//#region src/browser/types.d.ts
 /**
- * Mock handler function type for testing FaasJS requests.
+ * Template literal type for URL strings that must end with a forward slash.
+ */
+type BaseUrl = `${string}/`;
+/**
+ * Configuration options for FaasJS requests.
  *
- * Defines the signature for functions that can mock API requests during testing.
- * Mock handlers receive request parameters and return simulated responses or errors.
- *
- * @param {string} action - The function path/action being requested (for example, `user` or `data/list`).
- *   Converted to lowercase by the client before being passed to the handler.
- *
- * @param {Record<string, any> | undefined} params - The parameters passed to the action.
- *   May be undefined if the action was called without parameters.
- *   Parameters are passed as a plain object (already JSON-serialized if needed).
- *
- * @param {Options} options - The full request options including headers, beforeRequest hook, and other config.
- *   Includes X-FaasJS-Request-Id header in the headers object.
- *   Contains merged client defaults and per-request options.
- *   See {@link Options} for supported request fields such as `headers`, `beforeRequest`,
- *   `request`, `baseUrl`, and `stream`.
- *
- * @returns {Promise<ResponseProps> | Promise<void> | Promise<Error>} A promise resolving to:
- *   - ResponseProps: Mock response data (status, headers, body, data)
- *   - void: Returns an empty response (204 No Content)
- *   - Error: Throws ResponseError when returning an Error object
- *
- * Notes:
- * - Used by setMock() function to mock API calls during tests
- * - Affects all FaasBrowserClient instances when set globally
- * - Can return different responses based on action or params
- * - Returning an Error object causes the action() method to reject with ResponseError
- * - Async function - must return a Promise
- * - Receives the fully merged options including default headers
- * @see {@link setMock} for setting up mock handlers.
- * @see {@link ResponseProps} for response structure.
- * @see {@link ResponseError} for error handling.
+ * Extends the standard RequestInit interface with FaasJS-specific options for
+ * customizing request behavior, adding request hooks, and overriding defaults.
+ */
+type Options = RequestInit & {
+  headers?: Record<string, string>; /** Async hook called after request options are merged but before the request is sent. */
+  beforeRequest?: ({
+    action,
+    params,
+    options,
+    headers
+  }: {
+    action: string;
+    params?: Record<string, any> | undefined;
+    options: Options;
+    headers: Record<string, string>;
+  }) => Promise<void>; /** Custom request implementation used instead of the native `fetch`. */
+  request?: <PathOrData extends FaasActionUnionType$1>(url: string, options: Options) => Promise<Response<FaasData$1<PathOrData>>>; /** Base URL override for the current request. */
+  baseUrl?: BaseUrl; /** When `true`, return the native fetch response so callers can consume the stream manually. */
+  stream?: boolean;
+};
+/**
+ * Simple key-value object for HTTP response headers.
+ */
+type ResponseHeaders = {
+  [key: string]: string;
+};
+/**
+ * Type definition for the FaasBrowserClient.action method.
+ */
+type FaasBrowserClientAction = <PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, params?: FaasParams$1<PathOrData>, options?: Options) => Promise<Response<FaasData$1<PathOrData>> | Response>;
+/**
+ * Properties for creating a Response object.
+ */
+type ResponseProps<T = any> = {
+  status?: number;
+  headers?: ResponseHeaders;
+  body?: any;
+  data?: T;
+};
+/**
+ * Input accepted by the {@link ResponseError} constructor.
+ */
+type ResponseErrorProps = {
+  /** User-facing error message. */message: string; /** HTTP status code reported for the error. @default 500 */
+  status?: number; /** Response headers returned with the error. @default {} */
+  headers?: ResponseHeaders; /** Raw error body or structured error payload. @default { error: { message } } */
+  body?: any; /** Original error preserved when this instance wraps another exception. */
+  originalError?: Error;
+};
+/**
+ * Mock handler function type for testing FaasJS requests.
  */
 type MockHandler = (action: string, params: Record<string, any> | undefined, options: Options) => Promise<ResponseProps> | Promise<void> | Promise<Error>;
+//#endregion
+//#region src/browser/mock.d.ts
 /**
  * Set the global mock handler used by all {@link FaasBrowserClient} instances.
- *
- * @param {MockHandler | ResponseProps | Response | null | undefined} handler - Mock handler, can be:
- *   - MockHandler function: receives (action, params, options) and returns response data
- *   - ResponseProps object: static response data
- *   - Response instance: pre-configured Response object
- *   - null or undefined: clear mock
- *
- * @example Reset in Vitest shared setup
- * ```ts
- * import { afterEach } from 'vitest'
- *
- * afterEach(() => {
- *   setMock(null)
- * })
- * ```
- *
- * @example Use ResponseProps object
- * ```ts
- * setMock({
- *   data: { name: 'FaasJS' },
- * })
- *
- * setMock({
- *   status: 500,
- *   data: { message: 'Internal Server Error' },
- * })
- * ```
- *
- * @example Use MockHandler function
- * ```ts
- * setMock(async (action) => {
- *   if (action === '/pages/users/get') {
- *     return { data: { id: 1, name: 'FaasJS' } }
- *   }
- *
- *   return { status: 404, data: { message: 'Not Found' } }
- * })
- *
- * const response = await client.action('/pages/users/get')
- * ```
- *
- * @example Branch by action and params
- * ```ts
- * setMock(async (action, params) => {
- *   if (action === '/pages/users/get' && params?.id === 1) {
- *     return { data: { id: 1, name: 'Admin' } }
- *   }
- *
- *   if (action === '/pages/users/get' && params?.id === 2) {
- *     return { data: { id: 2, name: 'Editor' } }
- *   }
- *
- *   return { status: 404, data: { message: 'User not found' } }
- * })
- * ```
- *
- * @example Use Response instance
- * ```ts
- * setMock(new Response({
- *   status: 200,
- *   data: { result: 'success' }
- * }))
- * ```
- *
- * @example Streaming response
- * ```ts
- * setMock({
- *   body: new ReadableStream({
- *     start(controller) {
- *       controller.enqueue(new TextEncoder().encode('hello'))
- *       controller.enqueue(new TextEncoder().encode(' world'))
- *       controller.close()
- *     },
- *   }),
- * })
- * ```
- *
- * @example Clear mock
- * ```ts
- * setMock(null)
- * ```
- *
- * @example Handle errors
- * ```ts
- * setMock(async () => {
- *   throw new Error('Internal error')
- * })
- * // This will reject with ResponseError
- * ```
  */
 declare function setMock(handler: MockHandler | ResponseProps | Response | null | undefined): void;
+//#endregion
+//#region src/browser/client.d.ts
 /**
  * Browser client for FaasJS - provides HTTP client functionality for making API requests from web applications.
- *
- * @template PathOrData - Type parameter extending FaasActionUnionType for type-safe requests
- *
- * Features:
- * - Type-safe API requests with TypeScript support
- * - Built-in mock support for testing
- * - Custom request function support
- * - Request/response hooks (beforeRequest)
- * - Automatic error handling with ResponseError
- * - Streaming support for large responses
- * - Multiple instance support with unique IDs
- *
- * Notes:
- * - All requests are POST requests by default
- * - Automatically adds X-FaasJS-Request-Id header for request tracking
- * - baseUrl must end with '/' (will throw Error if not)
- * - Supports global mock via setMock() for testing all instances
- *
- * @example Basic usage
- * ```ts
- * import { FaasBrowserClient } from '@faasjs/react'
- *
- * const client = new FaasBrowserClient('http://localhost:8080/')
- * const response = await client.action('func', { key: 'value' })
- * console.log(response.data)
- * ```
- *
- * @example With custom headers and options
- * ```ts
- * const client = new FaasBrowserClient('https://api.example.com/', {
- *   headers: { 'X-API-Key': 'secret' },
- *   beforeRequest: async ({ action, params, headers }) => {
- *     console.log(`Calling ${action} with params:`, params)
- *   }
- * })
- * ```
- *
- * @example Multiple instances
- * ```ts
- * const apiClient = new FaasBrowserClient('https://api.example.com/')
- * const localClient = new FaasBrowserClient('http://localhost:3000/')
- *
- * const apiData = await apiClient.action('users')
- * const localData = await localClient.action('data')
- * ```
- *
- * @example Error handling
- * ```ts
- * const client = new FaasBrowserClient('https://api.example.com/')
- *
- * try {
- *   const response = await client.action('user', { id: 123 })
- *   console.log(response.data)
- * } catch (error) {
- *   if (error instanceof ResponseError) {
- *     console.error(`Request failed: ${error.message}`, error.status)
- *   } else {
- *     console.error('Unexpected error:', error)
- *   }
- * }
- * ```
- *
- * @throws {Error} When baseUrl does not end with '/'
- *
- * @see {@link setMock} for testing support.
- * @see {@link ResponseError} for error handling.
  */
 declare class FaasBrowserClient {
   /**
@@ -684,166 +171,10 @@ declare class FaasBrowserClient {
   defaultOptions: Options;
   /**
    * Creates a new FaasBrowserClient instance.
-   *
-   * @param {BaseUrl} [baseUrl] - Base URL for all API requests. Must end with `/`. Defaults to `/` for relative requests.
-   * @param {Options} [options] - Default request options such as headers, hooks, request override, or stream mode.
-   * See {@link Options} for supported request fields such as `headers`, `beforeRequest`,
-   * `request`, `baseUrl`, and `stream`.
-   *
-   * @example Basic initialization
-   * ```ts
-   * const client = new FaasBrowserClient('/')
-   * ```
-   *
-   * @example With API endpoint
-   * ```ts
-   * const client = new FaasBrowserClient('https://api.example.com/')
-   * ```
-   *
-   * @example With custom headers
-   * ```ts
-   * const client = new FaasBrowserClient('https://api.example.com/', {
-   *   headers: {
-   *     'Authorization': 'Bearer token123',
-   *     'X-Custom-Header': 'value'
-   *   }
-   * })
-   * ```
-   *
-   * @example With beforeRequest hook
-   * ```ts
-   * const client = new FaasBrowserClient('https://api.example.com/', {
-   *   beforeRequest: async ({ action, params, headers }) => {
-   *     console.log(`Requesting ${action}`, params)
-   *     // Modify headers before request
-   *     headers['X-Timestamp'] = Date.now().toString()
-   *   }
-   * })
-   * ```
-   *
-   * @example With custom request function
-   * ```ts
-   * import axios from 'axios'
-   *
-   * const client = new FaasBrowserClient('/', {
-   *   request: async (url, options) => {
-   *     const response = await axios.post(url, options.body, {
-   *       headers: options.headers
-   *     })
-   *     return new Response({
-   *       status: response.status,
-   *       headers: response.headers,
-   *       data: response.data
-   *     })
-   *   }
-   * })
-   * ```
-   *
-   * @throws {Error} When `baseUrl` does not end with `/`
    */
   constructor(baseUrl?: BaseUrl, options?: Options);
   /**
    * Makes a request to a FaasJS function.
-   *
-   * @template PathOrData - The function path or data type for type safety
-   * @param {FaasAction<PathOrData>} action - The function path to call. Converted to lowercase when constructing the URL.
-   *   Must be a non-empty string.
-   * @param {FaasParams<PathOrData>} [params] - The parameters to send to the function. Will be serialized as JSON.
-   *   Optional if the function accepts no parameters.
-   * @param {Options} [options] - Optional request options that override client defaults.
-   *   Supports headers, beforeRequest hook, custom request function, baseUrl override, and streaming mode.
-   *   See {@link Options} for supported request fields such as `headers`, `beforeRequest`,
-   *   `request`, `baseUrl`, and `stream`.
-   *
-   * @returns {Promise<Response<FaasData<PathOrData>>>} A promise resolving to the wrapped FaasJS response. When `options.stream`
-   *   is `true`, the runtime returns the native fetch response so callers can read the stream.
-   *
-   * @throws {Error} When action is not provided or is empty
-   * @throws {ResponseError} When the server returns an error response (status >= 400 or body.error exists)
-   * @throws {Error} When the request fails before a response is received
-   *
-   * Notes:
-   * - All requests are POST requests by default
-   * - Action path is automatically converted to lowercase
-   * - A unique request ID is generated for each request and sent in X-FaasJS-Request-Id header
-   * - Headers are merged from client defaults and request options (request options take precedence)
-   * - If a global mock is set via setMock(), it will be used instead of making real requests
-   * - If a custom request function is provided in options, it will be used instead of fetch
-   * - When stream option is true, returns the native fetch Response instead of a wrapped Response
-   * - Response body is automatically parsed as JSON when possible
-   * - Server errors (body.error) are automatically converted to ResponseError
-   *
-   * @example Basic request
-   * ```ts
-   * const response = await client.action('user', { id: 123 })
-   * console.log(response.data)
-   * ```
-   *
-   * @example With no parameters
-   * ```ts
-   * const response = await client.action('status')
-   * console.log(response.data.status)
-   * ```
-   *
-   * @example With custom options
-   * ```ts
-   * const response = await client.action('data', {
-   *   limit: 10,
-   *   offset: 0
-   * }, {
-   *   headers: { 'X-Custom-Header': 'value' }
-   * })
-   * ```
-   *
-   * @example Streaming large response
-   * ```ts
-   * const response = await client.action('stream', {
-   *   format: 'json'
-   * }, {
-   *   stream: true
-   * })
-   * // response is native fetch Response with streaming support
-   * const reader = response.body.getReader()
-   * ```
-   *
-   * @example With type safety
-   * ```ts
-   * interface UserData {
-   *   id: number
-   *   name: string
-   *   email: string
-   * }
-   *
-   * const response = await client.action<UserData>('user', { id: 123 })
-   * console.log(response.data.name) // TypeScript knows it's a string
-   * ```
-   *
-   * @example Handling errors
-   * ```ts
-   * try {
-   *   const response = await client.action('user', { id: 123 })
-   *   console.log(response.data)
-   * } catch (error) {
-   *   if (error instanceof ResponseError) {
-   *     console.error(`Server error: ${error.message}`, error.status)
-   *     if (error.body) console.error('Error details:', error.body)
-   *   } else {
-   *     console.error('Network error:', error)
-   *   }
-   * }
-   * ```
-   *
-   * @example Chaining requests
-   * ```ts
-   * const userId = await client.action('createUser', {
-   *   name: 'John',
-   *   email: 'john@example.com'
-   * })
-   *
-   * const profile = await client.action('getProfile', {
-   *   userId: userId.data.id
-   * })
-   * ```
    */
   action<PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, params?: FaasParams$1<PathOrData>, options?: Options): Promise<Response<FaasData$1<PathOrData>>>;
 }
@@ -1079,7 +410,7 @@ type SharedUseFaasOptions<Params, Data> = {
  *
  * @template PathOrData - Action path or response data type used for inference.
  */
-type useFaasOptions<PathOrData extends FaasActionUnionType$1> = SharedUseFaasOptions<FaasParams$1<PathOrData>, FaasData$1<PathOrData>>;
+type UseFaasOptions<PathOrData extends FaasActionUnionType$1> = SharedUseFaasOptions<FaasParams$1<PathOrData>, FaasData$1<PathOrData>>;
 /**
  * Request FaasJS data and keep request state in React state.
  *
@@ -1091,8 +422,8 @@ type useFaasOptions<PathOrData extends FaasActionUnionType$1> = SharedUseFaasOpt
  *
  * @param {FaasAction<PathOrData>} action - Action path to invoke.
  * @param {FaasParams<PathOrData>} defaultParams - Params used for the initial request and future reloads.
- * @param {useFaasOptions<PathOrData>} [options] - Optional hook configuration such as controlled data, skip logic, debounce timing, polling, and base URL overrides.
- * See the `useFaasOptions` type for `params`, `data`, `setData`, `skip`, `debounce`, `polling`, and `baseUrl`.
+ * @param {UseFaasOptions<PathOrData>} [options] - Optional hook configuration such as controlled data, skip logic, debounce timing, polling, and base URL overrides.
+ * See the `UseFaasOptions` type for `params`, `data`, `setData`, `skip`, `debounce`, `polling`, and `baseUrl`.
  * @returns {FaasDataInjection<PathOrData>} Request state and helper methods described by {@link FaasDataInjection}.
  *
  * @example
@@ -1126,7 +457,7 @@ type useFaasOptions<PathOrData extends FaasActionUnionType$1> = SharedUseFaasOpt
  * }
  * ```
  */
-declare function useFaas<PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, defaultParams: FaasParams$1<PathOrData>, options?: useFaasOptions<PathOrData>): FaasDataInjection<PathOrData>;
+declare function useFaas<PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, defaultParams: FaasParams$1<PathOrData>, options?: UseFaasOptions<PathOrData>): FaasDataInjection<PathOrData>;
 //#endregion
 //#region src/client.d.ts
 /**
@@ -1236,7 +567,7 @@ declare function FaasReactClient(options?: FaasReactClientOptions): FaasReactCli
  */
 declare function getClient(host?: string): FaasReactClientInstance;
 //#endregion
-//#region src/constant/index.d.ts
+//#region src/constants/index.d.ts
 /**
  * Returns a constant value that is created by the given function.
  *
@@ -1477,7 +808,7 @@ declare namespace OptionalWrapper {
   var displayName: string;
 }
 //#endregion
-//#region src/splittingContext/index.d.ts
+//#region src/splitting-context/index.d.ts
 /**
  * Create a context whose keys can be consumed independently.
  *
@@ -1593,7 +924,7 @@ declare function createSplittingContext<T extends Record<string, any>>(defaultVa
   use: <NewT extends T = T>(this: void) => Readonly<NewT>;
 };
 //#endregion
-//#region src/splittingState/index.d.ts
+//#region src/splitting-state/index.d.ts
 /**
  * Setter map generated by {@link useSplittingState} for each state key.
  *
@@ -1734,4 +1065,4 @@ declare function usePrevious<T = any>(value: T): T | undefined;
  */
 declare function useStateRef<T = any>(initialValue?: T): [T | null, Dispatch<SetStateAction<T | null>>, RefObject<T | null>];
 //#endregion
-export { BaseUrl, ErrorBoundary, ErrorBoundaryProps, ErrorChildrenProps, type FaasAction, type FaasActionUnionType, FaasBrowserClient, FaasBrowserClientAction, type FaasData, FaasDataInjection, FaasDataWrapper, FaasDataWrapperProps, FaasDataWrapperRef, type FaasParams, FaasReactClient, FaasReactClientInstance, FaasReactClientOptions, MockHandler, OnError, OptionalWrapper, OptionalWrapperProps, Options, Response, ResponseError, ResponseErrorProps, ResponseHeaders, ResponseProps, StateSetters, StatesWithSetters, UseFaasStreamOptions, UseFaasStreamResult, createSplittingContext, equal, faas, generateId, getClient, setMock, useConstant, useEqualCallback, useEqualEffect, useEqualMemo, useEqualMemoize, useFaas, useFaasOptions, useFaasStream, usePrevious, useSplittingState, useStateRef, withFaasData };
+export { type BaseUrl, ErrorBoundary, ErrorBoundaryProps, ErrorChildrenProps, type FaasAction, type FaasActionUnionType, FaasBrowserClient, type FaasBrowserClientAction, type FaasData, FaasDataInjection, FaasDataWrapper, FaasDataWrapperProps, FaasDataWrapperRef, type FaasParams, FaasReactClient, FaasReactClientInstance, FaasReactClientOptions, type MockHandler, OnError, OptionalWrapper, OptionalWrapperProps, type Options, Response, ResponseError, type ResponseErrorProps, type ResponseHeaders, type ResponseProps, StateSetters, StatesWithSetters, UseFaasOptions, UseFaasStreamOptions, UseFaasStreamResult, createSplittingContext, equal, faas, generateId, getClient, setMock, useConstant, useEqualCallback, useEqualEffect, useEqualMemo, useEqualMemoize, useFaas, useFaasStream, usePrevious, useSplittingState, useStateRef, withFaasData };