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

package/README.md

@@ -37,14 +37,10 @@
 
 - [BaseUrl](type-aliases/BaseUrl.md)
 - [ErrorChildrenProps](type-aliases/ErrorChildrenProps.md)
-- [FaasAction](type-aliases/FaasAction.md)
-- [FaasActionUnionType](type-aliases/FaasActionUnionType.md)
 - [FaasBrowserClientAction](type-aliases/FaasBrowserClientAction.md)
-- [FaasData](type-aliases/FaasData.md)
 - [FaasDataInjection](type-aliases/FaasDataInjection.md)
 - [FaasDataWrapperProps](type-aliases/FaasDataWrapperProps.md)
 - [FaasDataWrapperRef](type-aliases/FaasDataWrapperRef.md)
-- [FaasParams](type-aliases/FaasParams.md)
 - [FaasReactClientInstance](type-aliases/FaasReactClientInstance.md)
 - [FaasReactClientOptions](type-aliases/FaasReactClientOptions.md)
 - [MockHandler](type-aliases/MockHandler.md)

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _$react from "react";
 import { Component, ComponentProps, ComponentType, Dispatch, ErrorInfo, JSX, ReactElement, ReactNode, RefObject, SetStateAction } from "react";
 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";
+import { FaasActionPaths, FaasData, FaasParams } from "@faasjs/types";
 
 //#region src/generate-id/index.d.ts
 /**
@@ -108,7 +108,7 @@ type Options = RequestInit & {
     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. */
+  request?: (url: string, options: Options) => Promise<Response>; /** 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;
 };
@@ -121,7 +121,7 @@ type ResponseHeaders = {
 /**
  * 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>;
+type FaasBrowserClientAction = <Path extends FaasActionPaths>(action: Path, params?: FaasParams<Path>, options?: Options) => Promise<Response<FaasData<Path>> | Response>;
 /**
  * Properties for creating a Response object.
  */
@@ -176,7 +176,7 @@ declare class FaasBrowserClient {
   /**
    * Makes a request to a FaasJS function.
    */
-  action<PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, params?: FaasParams$1<PathOrData>, options?: Options): Promise<Response<FaasData$1<PathOrData>>>;
+  action<Path extends FaasActionPaths>(action: Path, params: FaasParams<Path>, options?: Options): Promise<Response<FaasData<Path>>>;
 }
 //#endregion
 //#region src/faas/index.d.ts
@@ -186,14 +186,14 @@ declare class FaasBrowserClient {
  * This helper forwards the request to `getClient`. When the registered
  * client defines `onError`, the hook is invoked before the promise rejects.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  *
- * @param {FaasAction<PathOrData>} action - Action path to invoke.
- * @param {FaasParams<PathOrData>} params - Parameters sent to the action.
+ * @param {Path} action - Action path to invoke.
+ * @param {FaasParams<Path>} params - Parameters sent to the action.
  * @param {Options} [options] - Optional per-request overrides such as headers or base URL.
  * See the browser-client `Options` type for supported fields such as `headers`, `beforeRequest`,
  * `request`, `baseUrl`, and `stream`.
- * @returns {Promise<Response<FaasData<PathOrData>>>} Response returned by the active browser client.
+ * @returns {Promise<Response<FaasData<Path>>>} Response returned by the active browser client.
  * @throws {ResponseError} When the request fails and the active client does not recover inside `onError`.
  *
  * @example
@@ -205,77 +205,77 @@ declare class FaasBrowserClient {
  * console.log(response.data.title)
  * ```
  */
-declare function faas<PathOrData extends FaasActionUnionType$1>(action: FaasAction$1<PathOrData>, params: FaasParams$1<PathOrData>, options?: Options): Promise<Response<FaasData$1<PathOrData>>>;
+declare function faas<Path extends FaasActionPaths>(action: Path, params: FaasParams<Path>, options?: Options): Promise<Response<FaasData<Path>>>;
 //#endregion
 //#region src/FaasDataWrapper/index.d.ts
 /**
  * Request state injected by {@link useFaas}, {@link FaasDataWrapper}, and {@link withFaasData}.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  */
-type FaasDataInjection<PathOrData extends FaasActionUnionType$1 = any> = {
-  /** Action path associated with the current request state. */action: FaasAction$1<PathOrData>; /** Params used for the most recent request attempt. */
-  params: FaasParams$1<PathOrData>; /** Whether the request is currently in flight and should block the main UI. */
+type FaasDataInjection<Path extends FaasActionPaths> = {
+  /** Action path associated with the current request state. */action: Path; /** Params used for the most recent request attempt. */
+  params: FaasParams<Path>; /** Whether the request is currently in flight and should block the main UI. */
   loading: boolean; /** Whether a background refresh request is currently in flight. */
   refreshing: boolean; /** Number of times `reload()` or polling has triggered a new request. */
   reloadTimes: number; /** Current resolved data value. */
-  data: FaasData$1<PathOrData>; /** Last request error, if one occurred. */
+  data: FaasData<Path>; /** Last request error, if one occurred. */
   error: any; /** Promise representing the latest request. */
-  promise: Promise<Response<FaasData$1<PathOrData>>>;
+  promise: Promise<Response<FaasData<Path>>>;
   /**
    * Reloads data with new or existing parameters.
    *
    * When the source hook is currently skipped, calling `reload` clears the skip
    * flag before starting the next request.
    */
-  reload(params?: Record<string, any>, options?: {
+  reload(params?: FaasParams<Path>, options?: {
     silent?: boolean;
-  }): Promise<FaasData$1<PathOrData>>; /** Controlled or internal setter for the resolved data value. */
-  setData: React.Dispatch<React.SetStateAction<FaasData$1<PathOrData>>>; /** Setter for the loading flag. */
+  }): Promise<FaasData<Path>>; /** Controlled or internal setter for the resolved data value. */
+  setData: React.Dispatch<React.SetStateAction<FaasData<Path>>>; /** Setter for the loading flag. */
   setLoading: React.Dispatch<React.SetStateAction<boolean>>; /** Setter for the latest request promise. */
-  setPromise: React.Dispatch<React.SetStateAction<Promise<Response<FaasData$1<PathOrData>>>>>; /** Setter for the last request error. */
+  setPromise: React.Dispatch<React.SetStateAction<Promise<Response<FaasData<Path>>>>>; /** Setter for the last request error. */
   setError: React.Dispatch<React.SetStateAction<any>>;
 };
 /**
  * Props for the {@link FaasDataWrapper} render-prop component.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  */
-type FaasDataWrapperProps<PathOrData extends FaasActionUnionType$1> = {
-  /** Render prop invoked with the resolved request state after the first load completes. */render?(args: FaasDataInjection<PathOrData>): JSX.Element | JSX.Element[]; /** Child element cloned with injected request state after the first load completes. */
-  children?: React.ReactElement<Partial<FaasDataInjection<PathOrData>>>; /** Element rendered before the first successful load. */
+type FaasDataWrapperProps<Path extends FaasActionPaths> = {
+  /** Render prop invoked with the resolved request state after the first load completes. */render?(args: FaasDataInjection<Path>): JSX.Element | JSX.Element[]; /** Child element cloned with injected request state after the first load completes. */
+  children?: React.ReactElement<Partial<FaasDataInjection<Path>>>; /** Element rendered before the first successful load. */
   fallback?: JSX.Element | false; /** Action path to request. */
-  action: FaasAction$1<PathOrData>; /** Params sent to the action. */
-  params?: FaasParams$1<PathOrData>; /** Milliseconds to wait after each completed request before refreshing data in the background. */
+  action: Path; /** Params sent to the action. */
+  params?: FaasParams<Path>; /** Milliseconds to wait after each completed request before refreshing data in the background. */
   polling?: number | false; /** Callback invoked whenever the resolved data value changes. */
-  onDataChange?(args: FaasDataInjection<PathOrData>): void; /** Controlled data value used instead of internal state. */
-  data?: FaasData$1<PathOrData>; /** Controlled setter used instead of internal state. */
-  setData?: React.Dispatch<React.SetStateAction<FaasData$1<PathOrData>>>; /** Base URL override used for this wrapper instance. */
+  onDataChange?(args: FaasDataInjection<Path>): void; /** Controlled data value used instead of internal state. */
+  data?: FaasData<Path>; /** Controlled setter used instead of internal state. */
+  setData?: React.Dispatch<React.SetStateAction<FaasData<Path>>>; /** Base URL override used for this wrapper instance. */
   baseUrl?: BaseUrl; /** Imperative ref exposing the current injected request state. */
-  ref?: React.Ref<FaasDataWrapperRef<PathOrData>>;
+  ref?: React.Ref<FaasDataWrapperRef<Path>>;
 };
 /**
  * Imperative ref shape exposed by {@link FaasDataWrapper}.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  */
-type FaasDataWrapperRef<PathOrData extends FaasActionUnionType$1 = any> = FaasDataInjection<PathOrData>;
+type FaasDataWrapperRef<Path extends FaasActionPaths> = FaasDataInjection<Path>;
 /**
  * Fetch FaasJS data and inject the result into a render prop or child element.
  *
  * The wrapper defers rendering `children` or `render` until the first request
  * completes, then keeps passing the latest request state to the rendered output.
  *
- * @param {FaasDataWrapperProps<PathOrData>} props - Wrapper props controlling the request and rendered fallback.
- * @param {(args: FaasDataInjection<PathOrData>) => JSX.Element | JSX.Element[]} [props.render] - Render prop that receives the resolved Faas request state.
- * @param {React.ReactElement<Partial<FaasDataInjection<PathOrData>>>} [props.children] - Child element cloned with injected Faas request state.
+ * @param {FaasDataWrapperProps<Path>} props - Wrapper props controlling the request and rendered fallback.
+ * @param {(args: FaasDataInjection<Path>) => JSX.Element | JSX.Element[]} [props.render] - Render prop that receives the resolved Faas request state.
+ * @param {React.ReactElement<Partial<FaasDataInjection<Path>>>} [props.children] - Child element cloned with injected Faas request state.
  * @param {JSX.Element | false} [props.fallback] - Element rendered before the first successful load.
- * @param {FaasAction<PathOrData>} props.action - Action path to request.
- * @param {FaasParams<PathOrData>} [props.params] - Params sent to the action.
+ * @param {Path} props.action - Action path to request.
+ * @param {FaasParams<Path>} [props.params] - Params sent to the action.
  * @param {number | false} [props.polling] - Milliseconds to wait after each completed request before refreshing data in the background.
- * @param {(args: FaasDataInjection<PathOrData>) => void} [props.onDataChange] - Callback invoked when the resolved data value changes.
- * @param {FaasData<PathOrData>} [props.data] - Controlled data value used instead of internal state.
- * @param {React.Dispatch<React.SetStateAction<FaasData<PathOrData>>>} [props.setData] - Controlled setter used instead of internal state.
+ * @param {(args: FaasDataInjection<Path>) => void} [props.onDataChange] - Callback invoked when the resolved data value changes.
+ * @param {FaasData<Path>} [props.data] - Controlled data value used instead of internal state.
+ * @param {React.Dispatch<React.SetStateAction<FaasData<Path>>>} [props.setData] - Controlled setter used instead of internal state.
  * @param {BaseUrl} [props.baseUrl] - Base URL override used for this wrapper instance.
  *
  * @example
@@ -346,7 +346,7 @@ type FaasDataWrapperRef<PathOrData extends FaasActionUnionType$1 = any> = FaasDa
  *
  * When a ref is provided, it exposes the current Faas request state imperatively.
  */
-declare const FaasDataWrapper: <PathOrData extends FaasActionUnionType$1 = any>(props: FaasDataWrapperProps<PathOrData> & _$react.RefAttributes<FaasDataWrapperRef<PathOrData>>) => React.ReactElement | null;
+declare const FaasDataWrapper: <Path extends FaasActionPaths>(props: FaasDataWrapperProps<Path> & _$react.RefAttributes<FaasDataWrapperRef<Path>>) => React.ReactElement | null;
 /**
  * Wrap a component with {@link FaasDataWrapper} and inject Faas request state as props.
  *
@@ -354,11 +354,11 @@ declare const FaasDataWrapper: <PathOrData extends FaasActionUnionType$1 = any>(
  * preserve an existing component boundary. For new code, prefer `useFaas` or
  * `FaasDataWrapper` when they express the request ownership more directly.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  * @template TComponentProps - Component props including injected Faas data fields.
  * @param {React.FC<TComponentProps>} Component - Component that consumes injected Faas data props.
- * @param {FaasDataWrapperProps<PathOrData>} faasProps - Request configuration forwarded to `FaasDataWrapper`.
- * @returns {React.FC<Omit<TComponentProps, keyof FaasDataInjection<PathOrData>> & Record<string, any>>} Component that accepts the original props minus the injected Faas data fields.
+ * @param {FaasDataWrapperProps<Path>} faasProps - Request configuration forwarded to `FaasDataWrapper`.
+ * @returns {React.FC<Omit<TComponentProps, keyof FaasDataInjection<Path>> & Record<string, any>>} Component that accepts the original props minus the injected Faas data fields.
  *
  * @example
  * ```tsx
@@ -380,7 +380,7 @@ declare const FaasDataWrapper: <PathOrData extends FaasActionUnionType$1 = any>(
  * )
  * ```
  */
-declare function withFaasData<PathOrData extends FaasActionUnionType$1, TComponentProps extends Required<FaasDataInjection<PathOrData>> = Required<FaasDataInjection<PathOrData>>>(Component: React.FC<TComponentProps>, faasProps: FaasDataWrapperProps<PathOrData>): React.FC<Omit<TComponentProps, keyof FaasDataInjection<PathOrData>> & Record<string, any>>;
+declare function withFaasData<Path extends FaasActionPaths, TComponentProps extends Required<FaasDataInjection<Path>> = Required<FaasDataInjection<Path>>>(Component: React.FC<TComponentProps>, faasProps: FaasDataWrapperProps<Path>): React.FC<Omit<TComponentProps, keyof FaasDataInjection<Path>> & Record<string, any>>;
 //#endregion
 //#region src/useFaasRequest.d.ts
 /**
@@ -398,7 +398,7 @@ type SharedUseFaasOptions<Params, Data> = {
   params?: Params;
   data?: Data;
   setData?: React.Dispatch<React.SetStateAction<Data>>;
-  skip?: boolean | ((params: Params) => boolean);
+  skip?: boolean | ((params: Partial<Params>) => boolean);
   debounce?: number;
   polling?: number | false;
   baseUrl?: BaseUrl;
@@ -408,9 +408,9 @@ type SharedUseFaasOptions<Params, Data> = {
 /**
  * Options that customize the {@link useFaas} request lifecycle.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  */
-type UseFaasOptions<PathOrData extends FaasActionUnionType$1> = SharedUseFaasOptions<FaasParams$1<PathOrData>, FaasData$1<PathOrData>>;
+type UseFaasOptions<Path extends FaasActionPaths> = SharedUseFaasOptions<FaasParams<Path>, FaasData<Path>>;
 /**
  * Request FaasJS data and keep request state in React state.
  *
@@ -418,13 +418,13 @@ type UseFaasOptions<PathOrData extends FaasActionUnionType$1> = SharedUseFaasOpt
  * It sends an initial request unless `skip` is enabled, and returns request state
  * plus helpers for reloading, background refreshing, updating data, and handling errors.
  *
- * @template PathOrData - Action path or response data type used for inference.
+ * @template Path - Action path or response data type used for inference.
  *
- * @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.
+ * @param {Path} action - Action path to invoke.
+ * @param {FaasParams<Path>} defaultParams - Params used for the initial request and future reloads.
+ * @param {UseFaasOptions<Path>} [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}.
+ * @returns {FaasDataInjection<Path>} Request state and helper methods described by {@link FaasDataInjection}.
  *
  * @example
  * ```tsx
@@ -457,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<Path extends FaasActionPaths>(action: Path, defaultParams: FaasParams<Path>, options?: UseFaasOptions<Path>): FaasDataInjection<Path>;
 //#endregion
 //#region src/client.d.ts
 /**
@@ -962,16 +962,18 @@ declare function useSplittingState<T extends Record<string, unknown>>(initialSta
 type UseFaasStreamOptions = SharedUseFaasOptions<Record<string, any>, string>;
 /**
  * Result returned by {@link useFaasStream}.
+ *
+ * @template Path - Action path used for params inference.
  */
-type UseFaasStreamResult = {
-  /** Action path currently associated with the stream request. */action: string; /** Params used for the most recent request attempt. */
-  params: Record<string, any>; /** Whether the hook is currently waiting for stream data and should block the main UI. */
+type UseFaasStreamResult<Path extends FaasActionPaths> = {
+  /** Action path currently associated with the stream request. */action: Path; /** Params used for the most recent request attempt. */
+  params: FaasParams<Path>; /** Whether the hook is currently waiting for stream data and should block the main UI. */
   loading: boolean; /** Whether a background stream refresh is currently in flight. */
   refreshing: boolean; /** Number of times `reload()` or polling has triggered a new request. */
   reloadTimes: number; /** Accumulated text decoded from the stream response. */
   data: string; /** Last error raised while opening or consuming the stream. */
   error: any; /** Trigger a new streaming request with optional params. */
-  reload: (params?: Record<string, any>, options?: {
+  reload: (params?: FaasParams<Path>, options?: {
     silent?: boolean;
   }) => Promise<string>; /** Controlled or internal setter for the accumulated text. */
   setData: React.Dispatch<React.SetStateAction<string>>; /** Setter for the loading flag. */
@@ -1015,7 +1017,7 @@ type UseFaasStreamResult = {
  * }
  * ```
  */
-declare function useFaasStream(action: string, defaultParams: Record<string, any>, options?: UseFaasStreamOptions): UseFaasStreamResult;
+declare function useFaasStream<Path extends FaasActionPaths>(action: Path, defaultParams: FaasParams<Path>, options?: UseFaasStreamOptions): UseFaasStreamResult<Path>;
 //#endregion
 //#region src/usePrevious/index.d.ts
 /**
@@ -1065,4 +1067,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 { 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 };
+export { type BaseUrl, ErrorBoundary, ErrorBoundaryProps, ErrorChildrenProps, FaasBrowserClient, type FaasBrowserClientAction, FaasDataInjection, FaasDataWrapper, FaasDataWrapperProps, FaasDataWrapperRef, 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 };

package/dist/index.mjs

@@ -274,14 +274,14 @@ var FaasBrowserClient = class {
 * This helper forwards the request to `getClient`. When the registered
 * client defines `onError`, the hook is invoked before the promise rejects.
 *
-* @template PathOrData - Action path or response data type used for inference.
+* @template Path - Action path or response data type used for inference.
 *
-* @param {FaasAction<PathOrData>} action - Action path to invoke.
-* @param {FaasParams<PathOrData>} params - Parameters sent to the action.
+* @param {Path} action - Action path to invoke.
+* @param {FaasParams<Path>} params - Parameters sent to the action.
 * @param {Options} [options] - Optional per-request overrides such as headers or base URL.
 * See the browser-client `Options` type for supported fields such as `headers`, `beforeRequest`,
 * `request`, `baseUrl`, and `stream`.
-* @returns {Promise<Response<FaasData<PathOrData>>>} Response returned by the active browser client.
+* @returns {Promise<Response<FaasData<Path>>>} Response returned by the active browser client.
 * @throws {ResponseError} When the request fails and the active client does not recover inside `onError`.
 *
 * @example
@@ -465,16 +465,16 @@ function useEqualCallback(callback, dependencies) {
 * The wrapper defers rendering `children` or `render` until the first request
 * completes, then keeps passing the latest request state to the rendered output.
 *
-* @param {FaasDataWrapperProps<PathOrData>} props - Wrapper props controlling the request and rendered fallback.
-* @param {(args: FaasDataInjection<PathOrData>) => JSX.Element | JSX.Element[]} [props.render] - Render prop that receives the resolved Faas request state.
-* @param {React.ReactElement<Partial<FaasDataInjection<PathOrData>>>} [props.children] - Child element cloned with injected Faas request state.
+* @param {FaasDataWrapperProps<Path>} props - Wrapper props controlling the request and rendered fallback.
+* @param {(args: FaasDataInjection<Path>) => JSX.Element | JSX.Element[]} [props.render] - Render prop that receives the resolved Faas request state.
+* @param {React.ReactElement<Partial<FaasDataInjection<Path>>>} [props.children] - Child element cloned with injected Faas request state.
 * @param {JSX.Element | false} [props.fallback] - Element rendered before the first successful load.
-* @param {FaasAction<PathOrData>} props.action - Action path to request.
-* @param {FaasParams<PathOrData>} [props.params] - Params sent to the action.
+* @param {Path} props.action - Action path to request.
+* @param {FaasParams<Path>} [props.params] - Params sent to the action.
 * @param {number | false} [props.polling] - Milliseconds to wait after each completed request before refreshing data in the background.
-* @param {(args: FaasDataInjection<PathOrData>) => void} [props.onDataChange] - Callback invoked when the resolved data value changes.
-* @param {FaasData<PathOrData>} [props.data] - Controlled data value used instead of internal state.
-* @param {React.Dispatch<React.SetStateAction<FaasData<PathOrData>>>} [props.setData] - Controlled setter used instead of internal state.
+* @param {(args: FaasDataInjection<Path>) => void} [props.onDataChange] - Callback invoked when the resolved data value changes.
+* @param {FaasData<Path>} [props.data] - Controlled data value used instead of internal state.
+* @param {React.Dispatch<React.SetStateAction<FaasData<Path>>>} [props.setData] - Controlled setter used instead of internal state.
 * @param {BaseUrl} [props.baseUrl] - Base URL override used for this wrapper instance.
 *
 * @example
@@ -584,11 +584,11 @@ Object.assign(FaasDataWrapper, { displayName: "FaasDataWrapper" });
 * preserve an existing component boundary. For new code, prefer `useFaas` or
 * `FaasDataWrapper` when they express the request ownership more directly.
 *
-* @template PathOrData - Action path or response data type used for inference.
+* @template Path - Action path or response data type used for inference.
 * @template TComponentProps - Component props including injected Faas data fields.
 * @param {React.FC<TComponentProps>} Component - Component that consumes injected Faas data props.
-* @param {FaasDataWrapperProps<PathOrData>} faasProps - Request configuration forwarded to `FaasDataWrapper`.
-* @returns {React.FC<Omit<TComponentProps, keyof FaasDataInjection<PathOrData>> & Record<string, any>>} Component that accepts the original props minus the injected Faas data fields.
+* @param {FaasDataWrapperProps<Path>} faasProps - Request configuration forwarded to `FaasDataWrapper`.
+* @returns {React.FC<Omit<TComponentProps, keyof FaasDataInjection<Path>> & Record<string, any>>} Component that accepts the original props minus the injected Faas data fields.
 *
 * @example
 * ```tsx
@@ -625,16 +625,15 @@ function withFaasData(Component, faasProps) {
 * retry-on-fetch-failure, polling, and queued reload promises while delegating the
 * actual transport to `send`.
 *
-* @template Params - Request params type tracked by the lifecycle.
-* @template Result - Successful response payload type.
-* @template RequestPromise - Promise type exposed through `promiseRef`.
-* @param {UseFaasRequestArgs<Params, Result, RequestPromise>} args - Request lifecycle configuration.
+* @template Path - Action path used for request params inference.
+* @template TData - Data type returned by `send` and resolved by `reload()`.
+* @param {UseFaasRequestArgs<Path>} args - Request lifecycle configuration.
 * @param {string} args.action - Action path or request key used to trigger the lifecycle.
-* @param {Params} args.defaultParams - Initial params value stored by the lifecycle.
-* @param {Pick<SharedUseFaasOptions<Params, Result>, 'params' | 'skip' | 'debounce' | 'polling' | 'baseUrl'>} args.options - Shared request options used by the lifecycle.
+* @param {FaasParams<Path>} args.defaultParams - Initial params value stored by the lifecycle.
+* @param {Pick<SharedUseFaasOptions<FaasParams<Path>, FaasData<Path>>, 'params' | 'skip' | 'debounce' | 'polling' | 'baseUrl'>} args.options - Shared request options used by the lifecycle.
 * @param {(args: { silent: boolean }) => void} [args.beforeSend] - Optional callback invoked immediately before a request starts.
-* @param {(result: Result) => void} [args.onSuccess] - Optional callback invoked after a successful response.
-* @param {UseFaasRequestArgs<Params, Result, RequestPromise>['send']} args.send - Transport function responsible for creating and resolving the request.
+* @param {(result: FaasData<Path>) => void} [args.onSuccess] - Optional callback invoked after a successful response.
+* @param {UseFaasRequestArgs<Path>['send']} args.send - Transport function responsible for creating and resolving the request.
 * @returns Shared request state, reload helpers, and refs used by `useFaas` and `useFaasStream`.
 * @example
 * ```ts
@@ -833,13 +832,13 @@ function useFaasRequest({ action, defaultParams, options, beforeSend, onSuccess,
 * It sends an initial request unless `skip` is enabled, and returns request state
 * plus helpers for reloading, background refreshing, updating data, and handling errors.
 *
-* @template PathOrData - Action path or response data type used for inference.
+* @template Path - Action path or response data type used for inference.
 *
-* @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.
+* @param {Path} action - Action path to invoke.
+* @param {FaasParams<Path>} defaultParams - Params used for the initial request and future reloads.
+* @param {UseFaasOptions<Path>} [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}.
+* @returns {FaasDataInjection<Path>} Request state and helper methods described by {@link FaasDataInjection}.
 *
 * @example
 * ```tsx
@@ -883,10 +882,10 @@ function useFaas(action, defaultParams, options = {}) {
 			if (options.setData) options.setData(nextData);
 			else localSetData(nextData);
 		},
-		send: ({ action, params, signal, client, setPromise }) => {
+		send: async ({ action, params, signal, client, setPromise }) => {
 			const promise = client.faas(action, params, { signal });
 			setPromise(promise);
-			return promise.then((response) => response.data);
+			return (await promise).data;
 		}
 	});
 	const currentData = options.data ?? data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faasjs/react",
-  "version": "8.0.0-beta.29",
+  "version": "8.0.0-beta.30",
   "homepage": "https://faasjs.com/doc/react/",
   "bugs": {
     "url": "https://github.com/faasjs/faasjs/issues"
@@ -26,12 +26,12 @@
     }
   },
   "devDependencies": {
-    "@faasjs/types": ">=8.0.0-beta.29",
+    "@faasjs/types": ">=8.0.0-beta.30",
     "@types/react": "^19.0.0",
     "react": "^19.0.0"
   },
   "peerDependencies": {
-    "@faasjs/types": ">=8.0.0-beta.29"
+    "@faasjs/types": ">=8.0.0-beta.30"
   },
   "engines": {
     "node": ">=26.0.0",