@spoosh/react 0.10.1 → 0.12.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ReadClient, TagMode, SpooshResponse, SpooshPlugin, PluginTypeConfig, MergePluginResults, WriteSelectorClient, SpooshBody, StateManager, EventEmitter, PluginExecutor, PluginArray, ResolveTypes, MergePluginOptions, ResolverContext, ResolveResultTypes, MergePluginInstanceApi, SpooshOptions } from '@spoosh/core';
+import { ReadClient, TagMode, SpooshResponse, ExtractTriggerQuery as ExtractTriggerQuery$2, ExtractTriggerBody as ExtractTriggerBody$2, ExtractTriggerParams as ExtractTriggerParams$2, SpooshPlugin, PluginTypeConfig, MergePluginResults, WriteSelectorClient, SpooshBody, QueueSelectorClient, QueueItem, QueueStats, InfiniteRequestOptions, InfiniteNextContext, InfinitePage, InfinitePrevContext, StateManager, EventEmitter, PluginExecutor, PluginArray, ResolveTypes, MergePluginOptions, ResolverContext, ResolveResultTypes, MergePluginInstanceApi, SpooshOptions } from '@spoosh/core';
 
 type SuccessResponse<T> = Extract<T, {
     data: unknown;
@@ -81,28 +81,13 @@ type ResponseInputFields<TQuery, TBody, TParamNames extends string> = [
 ] extends [never, never, never] ? object : {
     input: ReadInputFields<TQuery, TBody, TParamNames>;
 };
-type TriggerAwaitedReturn$1<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
-type ExtractInputFromResponse$1<T> = T extends {
+type TriggerAwaitedReturn$3<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
+type ExtractInputFromResponse$3<T> = T extends {
     input: infer I;
 } ? I : never;
-type ExtractTriggerQuery$1<I> = I extends {
-    query: infer Q;
-} ? {
-    query?: Q;
-} : unknown;
-type ExtractTriggerBody$1<I> = I extends {
-    body: infer B;
-} ? {
-    body?: B;
-} : unknown;
-type ExtractTriggerParams$1<I> = I extends {
-    params: infer P;
-} ? {
-    params?: P;
-} : unknown;
-type TriggerOptions<T> = ExtractInputFromResponse$1<TriggerAwaitedReturn$1<T>> extends infer I ? [I] extends [never] ? {
+type TriggerOptions<T> = ExtractInputFromResponse$3<TriggerAwaitedReturn$3<T>> extends infer I ? [I] extends [never] ? {
     force?: boolean;
-} : ExtractTriggerQuery$1<I> & ExtractTriggerBody$1<I> & ExtractTriggerParams$1<I> & {
+} : ExtractTriggerQuery$2<I> & ExtractTriggerBody$2<I> & ExtractTriggerParams$2<I> & {
     /** Force refetch even if data is cached */
     force?: boolean;
 } : {
@@ -160,30 +145,30 @@ type InputFields<TQuery, TBody, TParamNames extends string> = OptionalQueryField
 type WriteResponseInputFields<TQuery, TBody, TParamNames extends string> = [TQuery, TBody, TParamNames] extends [never, never, never] ? object : {
     input: InputFields<TQuery, TBody, TParamNames> | undefined;
 };
-type TriggerAwaitedReturn<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;
-type ExtractInputFromResponse<T> = T extends {
+type TriggerAwaitedReturn$2<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;
+type ExtractInputFromResponse$2<T> = T extends {
     input: infer I;
 } ? I : never;
-type ExtractTriggerQuery<I> = I extends {
+type ExtractTriggerQuery$1<I> = I extends {
     query: infer Q;
 } ? undefined extends Q ? {
     query?: Exclude<Q, undefined>;
 } : {
     query: Q;
 } : unknown;
-type ExtractTriggerBody<I> = I extends {
+type ExtractTriggerBody$1<I> = I extends {
     body: infer B;
 } ? undefined extends B ? {
     body?: Exclude<B, undefined> | SpooshBody<Exclude<B, undefined>>;
 } : {
     body: B | SpooshBody<B>;
 } : unknown;
-type ExtractTriggerParams<I> = I extends {
+type ExtractTriggerParams$1<I> = I extends {
     params: infer P;
 } ? {
     params: P;
 } : unknown;
-type WriteTriggerInput<T> = ExtractInputFromResponse<TriggerAwaitedReturn<T>> extends infer I ? [I] extends [never] ? object : ExtractTriggerQuery<I> & ExtractTriggerBody<I> & ExtractTriggerParams<I> : object;
+type WriteTriggerInput<T> = ExtractInputFromResponse$2<TriggerAwaitedReturn$2<T>> extends infer I ? [I] extends [never] ? object : ExtractTriggerQuery$1<I> & ExtractTriggerBody$1<I> & ExtractTriggerParams$1<I> : object;
 /**
  * Result returned by `useWrite` hook.
  *
@@ -209,42 +194,93 @@ type BaseWriteResult<TData, TError, TOptions, TMeta = Record<string, unknown>> =
 type UseWriteResult<TData, TError, TOptions, TMeta, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]> = BaseWriteResult<TData, TError, TOptions, TMeta> & MergePluginResults<TPlugins>["write"];
 type WriteApiClient<TSchema, TDefaultError> = WriteSelectorClient<TSchema, TDefaultError>;
 
-type TagModeInArray = "all" | "self";
-type AnyInfiniteRequestOptions = {
-    query?: Record<string, unknown>;
-    params?: Record<string, string | number>;
-    body?: unknown;
+type TriggerAwaitedReturn$1<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;
+type ExtractInputFromResponse$1<T> = T extends {
+    input: infer I;
+} ? I : never;
+type ExtractTriggerQuery<I> = I extends {
+    query: infer Q;
+} ? undefined extends Q ? {
+    query?: Exclude<Q, undefined>;
+} : {
+    query: Q;
+} : unknown;
+type ExtractTriggerBody<I> = I extends {
+    body: infer B;
+} ? undefined extends B ? {
+    body?: Exclude<B, undefined> | SpooshBody<Exclude<B, undefined>>;
+} : {
+    body: B | SpooshBody<B>;
+} : unknown;
+type ExtractTriggerParams<I> = I extends {
+    params: infer P;
+} ? {
+    params: P;
+} : unknown;
+type QueueTriggerBase = {
+    /** Custom ID for this queue item. If not provided, one will be auto-generated. */
+    id?: string;
 };
+type QueueTriggerInput<T> = ExtractInputFromResponse$1<TriggerAwaitedReturn$1<T>> extends infer I ? [I] extends [never] ? QueueTriggerBase : QueueTriggerBase & ExtractTriggerQuery<I> & ExtractTriggerBody<I> & ExtractTriggerParams<I> : QueueTriggerBase;
 /**
- * Context passed to `canFetchNext` and `nextPageRequest` callbacks.
+ * Options for useQueue hook.
  */
-type InfiniteNextContext<TData, TRequest> = {
-    /** The latest fetched response data */
-    response: TData | undefined;
-    /** All responses fetched so far */
-    allResponses: TData[];
-    /** The current request options (query, params, body) */
-    request: TRequest;
+interface UseQueueOptions {
+    /** Maximum concurrent operations. Defaults to 3. */
+    concurrency?: number;
+}
+/**
+ * Result returned by useQueue hook.
+ *
+ * @template TData - The response data type
+ * @template TError - The error type
+ * @template TTriggerInput - The trigger input type
+ * @template TMeta - Plugin-contributed metadata on queue items
+ */
+type UseQueueResult<TData, TError, TTriggerInput, TMeta = object> = {
+    /** Add item to queue and execute. Returns promise for this item. */
+    trigger: (input?: TTriggerInput) => Promise<SpooshResponse<TData, TError>>;
+    /** All tasks in queue with their current status */
+    tasks: QueueItem<TData, TError, TMeta>[];
+    /** Queue statistics (pending/loading/settled/success/failed/total/percentage) */
+    stats: QueueStats;
+    /** Abort task by ID, or all tasks if no ID */
+    abort: (id?: string) => void;
+    /** Retry failed task by ID, or all failed if no ID */
+    retry: (id?: string) => Promise<void>;
+    /** Remove specific task by ID (aborts if active) */
+    remove: (id: string) => void;
+    /** Remove all settled tasks (success, error, aborted). Keeps pending/running. */
+    removeSettled: () => void;
+    /** Abort all and clear queue */
+    clear: () => void;
 };
 /**
- * Context passed to `canFetchPrev` and `prevPageRequest` callbacks.
+ * API client type for queue selector.
+ * Supports all HTTP methods (GET, POST, PUT, PATCH, DELETE).
  */
-type InfinitePrevContext<TData, TRequest> = {
-    /** The latest fetched response data */
-    response: TData | undefined;
-    /** All responses fetched so far */
-    allResponses: TData[];
-    /** The current request options (query, params, body) */
-    request: TRequest;
+type QueueApiClient<TSchema, TDefaultError> = QueueSelectorClient<TSchema, TDefaultError>;
+
+type TagModeInArray = "all" | "self";
+type TriggerAwaitedReturn<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
+type ExtractInputFromResponse<T> = T extends {
+    input: infer I;
+} ? I : never;
+type BaseTriggerOptions = {
+    /** Bypass cache and force refetch. Default: true */
+    force?: boolean;
 };
+type PagesTriggerOptions<TReadFn> = ExtractInputFromResponse<TriggerAwaitedReturn<TReadFn>> extends infer I ? [I] extends [never] ? BaseTriggerOptions : ExtractTriggerQuery$2<I> & ExtractTriggerBody$2<I> & ExtractTriggerParams$2<I> & BaseTriggerOptions : BaseTriggerOptions;
 /**
- * Options for `useInfiniteRead` hook.
+ * Options for `usePages` hook.
  *
  * @template TData - The response data type for each page
  * @template TItem - The item type after merging all responses
+ * @template TError - The error type
  * @template TRequest - The request options type (query, params, body)
+ * @template TMeta - Plugin metadata type
  */
-type BaseInfiniteReadOptions<TData, TItem, TRequest = AnyInfiniteRequestOptions> = {
+type BasePagesOptions<TData, TItem, TError = unknown, TRequest = InfiniteRequestOptions, TMeta = Record<string, unknown>> = {
     /** Whether to fetch automatically on mount. Default: true */
     enabled?: boolean;
     /**
@@ -255,30 +291,66 @@ type BaseInfiniteReadOptions<TData, TItem, TRequest = AnyInfiniteRequestOptions>
      *   - 'none' should only be used as string (use `tags: 'none'` not in array)
      */
     tags?: TagMode | (TagModeInArray | (string & {}))[];
-    /** Callback to determine if there's a next page to fetch */
-    canFetchNext: (ctx: InfiniteNextContext<TData, TRequest>) => boolean;
-    /** Callback to build the request options for the next page */
-    nextPageRequest: (ctx: InfiniteNextContext<TData, TRequest>) => Partial<TRequest>;
-    /** Callback to merge all responses into a single array of items */
-    merger: (allResponses: TData[]) => TItem[];
-    /** Callback to determine if there's a previous page to fetch */
-    canFetchPrev?: (ctx: InfinitePrevContext<TData, TRequest>) => boolean;
-    /** Callback to build the request options for the previous page */
-    prevPageRequest?: (ctx: InfinitePrevContext<TData, TRequest>) => Partial<TRequest>;
+    /**
+     * Callback to determine if there's a next page to fetch.
+     * Receives the last page to check for pagination indicators.
+     * Default: `() => false` (no next page fetching)
+     *
+     * @example
+     * ```ts
+     * canFetchNext: ({ lastPage }) => lastPage?.data?.nextCursor != null
+     * ```
+     */
+    canFetchNext?: (ctx: InfiniteNextContext<TData, TError, TRequest, TMeta>) => boolean;
+    /**
+     * Callback to build the request options for the next page.
+     * Return only the fields that change - they will be **merged** with the initial request.
+     * Default: `() => ({})` (no changes to request)
+     *
+     * @example
+     * ```ts
+     * // Initial: { query: { cursor: 0, limit: 10 } }
+     * // Only return cursor - limit is preserved automatically
+     * nextPageRequest: ({ lastPage }) => ({
+     *   query: { cursor: lastPage?.data?.nextCursor }
+     * })
+     * ```
+     */
+    nextPageRequest?: (ctx: InfiniteNextContext<TData, TError, TRequest, TMeta>) => Partial<TRequest>;
+    /**
+     * Callback to merge all pages into a single array of items.
+     *
+     * @example
+     * ```ts
+     * merger: (pages) => pages.flatMap(p => p.data?.items ?? [])
+     * ```
+     */
+    merger: (pages: InfinitePage<TData, TError, TMeta>[]) => TItem[];
+    /**
+     * Callback to determine if there's a previous page to fetch.
+     * Receives the first page to check for pagination indicators.
+     */
+    canFetchPrev?: (ctx: InfinitePrevContext<TData, TError, TRequest, TMeta>) => boolean;
+    /**
+     * Callback to build the request options for the previous page.
+     * Return only the fields that change - they will be **merged** with the initial request.
+     */
+    prevPageRequest?: (ctx: InfinitePrevContext<TData, TError, TRequest, TMeta>) => Partial<TRequest>;
 };
 /**
- * Result returned by `useInfiniteRead` hook.
+ * Result returned by `usePages` hook.
  *
  * @template TData - The response data type for each page
  * @template TError - The error type
  * @template TItem - The item type after merging all responses
  * @template TPluginResult - Plugin-provided result fields
+ * @template TTriggerOptions - Options that can be passed to trigger()
  */
-type BaseInfiniteReadResult<TData, TError, TItem, TPluginResult = Record<string, unknown>> = {
-    /** Merged items from all fetched responses */
+type BasePagesResult<TData, TError, TItem, TPluginResult = Record<string, unknown>, TTriggerOptions = object> = {
+    /** Merged items from all fetched pages */
     data: TItem[] | undefined;
-    /** Array of all raw response data */
-    allResponses: TData[] | undefined;
+    /** Array of all pages with status, data, error, and meta per page */
+    pages: InfinitePage<TData, TError, TPluginResult>[];
     /** True during the initial load (no data yet) */
     loading: boolean;
     /** True during any fetch operation */
@@ -291,26 +363,27 @@ type BaseInfiniteReadResult<TData, TError, TItem, TPluginResult = Record<string,
     canFetchNext: boolean;
     /** Whether there's a previous page available to fetch */
     canFetchPrev: boolean;
-    /** Plugin-provided metadata */
-    meta: TPluginResult;
     /** Fetch the next page */
     fetchNext: () => Promise<void>;
     /** Fetch the previous page */
     fetchPrev: () => Promise<void>;
-    /** Trigger refetch of all pages from the beginning */
-    trigger: () => Promise<void>;
+    /** Trigger refetch of all pages from the beginning, optionally with new request options */
+    trigger: (options?: TTriggerOptions) => Promise<void>;
     /** Abort the current fetch operation */
     abort: () => void;
     /** Error from the last failed request */
     error: TError | undefined;
 };
-type UseInfiniteReadResult<TData, TError, TItem, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]> = BaseInfiniteReadResult<TData, TError, TItem> & MergePluginResults<TPlugins>["read"];
-type InfiniteReadApiClient<TSchema, TDefaultError> = ReadClient<TSchema, TDefaultError>;
+type UsePagesResult<TData, TError, TItem, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[], TTriggerOptions = object> = BasePagesResult<TData, TError, TItem, MergePluginResults<TPlugins>["read"], TTriggerOptions>;
+type PagesApiClient<TSchema, TDefaultError> = ReadClient<TSchema, TDefaultError>;
 
 type InferError<T, TDefaultError> = [T] extends [unknown] ? TDefaultError : T;
 type WriteResolverContext<TSchema, TMethod, TDefaultError> = ResolverContext<TSchema, ExtractMethodData<TMethod>, InferError<ExtractMethodError<TMethod>, TDefaultError>, ExtractMethodQuery<TMethod>, ExtractMethodBody<TMethod>, ExtractResponseParamNames<TMethod> extends never ? never : Record<ExtractResponseParamNames<TMethod>, string | number>>;
 type ResolvedWriteOptions<TSchema, TPlugins extends PluginArray, TMethod, TDefaultError> = ResolveTypes<MergePluginOptions<TPlugins>["write"], WriteResolverContext<TSchema, TMethod, TDefaultError>>;
 type ResolvedWriteTriggerOptions<TSchema, TPlugins extends PluginArray, TMethod, TDefaultError> = ResolveTypes<MergePluginOptions<TPlugins>["writeTrigger"], WriteResolverContext<TSchema, TMethod, TDefaultError>>;
+type QueueResolverContext<TSchema, TMethod, TDefaultError> = ResolverContext<TSchema, ExtractMethodData<TMethod>, InferError<ExtractMethodError<TMethod>, TDefaultError>, ExtractMethodQuery<TMethod>, ExtractMethodBody<TMethod>, ExtractResponseParamNames<TMethod> extends never ? never : Record<ExtractResponseParamNames<TMethod>, string | number>>;
+type ResolvedQueueOptions<TSchema, TPlugins extends PluginArray, TMethod, TDefaultError> = ResolveTypes<MergePluginOptions<TPlugins>["queue"], QueueResolverContext<TSchema, TMethod, TDefaultError>>;
+type ResolvedQueueTriggerOptions<TSchema, TPlugins extends PluginArray, TMethod, TDefaultError> = ResolveTypes<MergePluginOptions<TPlugins>["queueTrigger"], QueueResolverContext<TSchema, TMethod, TDefaultError>>;
 type UseReadFn<TDefaultError, TSchema, TPlugins extends PluginArray> = {
     <TReadFn extends (api: ReadApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TReadOpts>(readFn: TReadFn, readOptions: TReadOpts & BaseReadOptions & ResolveTypes<MergePluginOptions<TPlugins>["read"], ResolverContext<TSchema, ExtractMethodData<TReadFn>, InferError<ExtractMethodError<TReadFn>, TDefaultError>, ExtractResponseQuery<TReadFn>, ExtractResponseBody<TReadFn>, ExtractResponseParamNames<TReadFn> extends never ? never : Record<ExtractResponseParamNames<TReadFn>, string | number>>>): BaseReadResult<ExtractMethodData<TReadFn>, InferError<ExtractMethodError<TReadFn>, TDefaultError>, ResolveResultTypes<MergePluginResults<TPlugins>["read"], TReadOpts>, TriggerOptions<TReadFn>> & ResponseInputFields<ExtractResponseQuery<TReadFn>, ExtractResponseBody<TReadFn>, ExtractResponseParamNames<TReadFn>>;
     <TReadFn extends (api: ReadApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>>(readFn: TReadFn): BaseReadResult<ExtractMethodData<TReadFn>, InferError<ExtractMethodError<TReadFn>, TDefaultError>, MergePluginResults<TPlugins>["read"], TriggerOptions<TReadFn>> & ResponseInputFields<ExtractResponseQuery<TReadFn>, ExtractResponseBody<TReadFn>, ExtractResponseParamNames<TReadFn>>;
@@ -318,17 +391,12 @@ type UseReadFn<TDefaultError, TSchema, TPlugins extends PluginArray> = {
 type UseWriteFn<TDefaultError, TSchema, TPlugins extends PluginArray> = {
     <TWriteFn extends (api: WriteApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TWriteOpts extends ResolvedWriteOptions<TSchema, TPlugins, TWriteFn, TDefaultError> = ResolvedWriteOptions<TSchema, TPlugins, TWriteFn, TDefaultError>>(writeFn: TWriteFn, writeOptions?: TWriteOpts): BaseWriteResult<ExtractMethodData<TWriteFn>, InferError<ExtractMethodError<TWriteFn>, TDefaultError>, WriteTriggerInput<TWriteFn> & ResolvedWriteTriggerOptions<TSchema, TPlugins, TWriteFn, TDefaultError>, ResolveResultTypes<MergePluginResults<TPlugins>["write"], TWriteOpts>> & WriteResponseInputFields<ExtractMethodQuery<TWriteFn>, ExtractMethodBody<TWriteFn>, ExtractResponseParamNames<TWriteFn>>;
 };
-type InfiniteReadResolverContext<TSchema, TData, TError, TRequest> = ResolverContext<TSchema, TData, TError, TRequest extends {
-    query: infer Q;
-} ? Q : never, TRequest extends {
-    body: infer B;
-} ? B : never, TRequest extends {
-    params: infer P;
-} ? P : never>;
-type ResolvedInfiniteReadOptions<TSchema, TPlugins extends PluginArray, TData, TError, TRequest> = ResolveTypes<MergePluginOptions<TPlugins>["infiniteRead"], InfiniteReadResolverContext<TSchema, TData, TError, TRequest>>;
-type UseInfiniteReadFn<TDefaultError, TSchema, TPlugins extends PluginArray> = <TData, TItem, TError = TDefaultError, TRequest extends AnyInfiniteRequestOptions = AnyInfiniteRequestOptions>(readFn: (api: InfiniteReadApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<TData, TError>>, readOptions: BaseInfiniteReadOptions<TData, TItem, TRequest> & ResolvedInfiniteReadOptions<TSchema, TPlugins, TData, TError, TRequest>) => BaseInfiniteReadResult<TData, TError, TItem, MergePluginResults<TPlugins>["read"]>;
+type UseQueueFn<TDefaultError, TSchema, TPlugins extends PluginArray> = {
+    <TQueueFn extends (api: QueueApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>>(queueFn: TQueueFn, queueOptions?: ResolvedQueueOptions<TSchema, TPlugins, TQueueFn, TDefaultError> & UseQueueOptions): UseQueueResult<ExtractMethodData<TQueueFn>, InferError<ExtractMethodError<TQueueFn>, TDefaultError>, QueueTriggerInput<TQueueFn> & ResolvedQueueTriggerOptions<TSchema, TPlugins, TQueueFn, TDefaultError>, ResolveResultTypes<MergePluginResults<TPlugins>["queue"], ResolvedQueueOptions<TSchema, TPlugins, TQueueFn, TDefaultError> & UseQueueOptions>>;
+};
+type UsePagesFn<TDefaultError, TSchema, TPlugins extends PluginArray> = <TReadFn extends (api: PagesApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TRequest extends InfiniteRequestOptions = InfiniteRequestOptions, TItem = unknown>(readFn: TReadFn, readOptions: BasePagesOptions<ExtractMethodData<TReadFn>, TItem, InferError<ExtractMethodError<TReadFn>, TDefaultError>, TRequest, MergePluginResults<TPlugins>["read"]> & ResolveTypes<MergePluginOptions<TPlugins>["pages"], ResolverContext<TSchema, ExtractMethodData<TReadFn>, InferError<ExtractMethodError<TReadFn>, TDefaultError>>>) => BasePagesResult<ExtractMethodData<TReadFn>, InferError<ExtractMethodError<TReadFn>, TDefaultError>, TItem, MergePluginResults<TPlugins>["read"], PagesTriggerOptions<TReadFn>>;
 /**
- * Spoosh React hooks interface containing useRead, useWrite, and useInfiniteRead.
+ * Spoosh React hooks interface containing useRead, useWrite, and usePages.
  *
  * @template TDefaultError - The default error type
  * @template TSchema - The API schema type
@@ -375,21 +443,41 @@ type SpooshReactHooks<TDefaultError, TSchema, TPlugins extends PluginArray> = {
      *
      * @param readFn - Function that selects the API endpoint to call
      * @param readOptions - Configuration including `canFetchNext`, `nextPageRequest`, `merger`, and optional `canFetchPrev`/`prevPageRequest`
-     * @returns Object containing `data`, `allResponses`, `fetchNext`, `fetchPrev`, `canFetchNext`, `canFetchPrev`, `loading`, `fetching`, and pagination states
+     * @returns Object containing `data`, `pages`, `fetchNext`, `fetchPrev`, `canFetchNext`, `canFetchPrev`, `loading`, `fetching`, and pagination states
      *
      * @example
      * ```tsx
-     * const { data, fetchNext, canFetchNext, loading } = useInfiniteRead(
+     * const { data, fetchNext, canFetchNext, loading } = usePages(
      *   (api) => api("posts").GET(),
      *   {
-     *     canFetchNext: ({ response }) => !!response?.nextCursor,
-     *     nextPageRequest: ({ response }) => ({ query: { cursor: response?.nextCursor } }),
-     *     merger: (responses) => responses.flatMap(r => r.items)
+     *     canFetchNext: ({ lastPage }) => !!lastPage?.data?.nextCursor,
+     *     nextPageRequest: ({ lastPage }) => ({ query: { cursor: lastPage?.data?.nextCursor } }),
+     *     merger: (pages) => pages.flatMap(p => p.data?.items ?? [])
      *   }
      * );
      * ```
      */
-    useInfiniteRead: UseInfiniteReadFn<TDefaultError, TSchema, TPlugins>;
+    usePages: UsePagesFn<TDefaultError, TSchema, TPlugins>;
+    /**
+     * React hook for queued operations with concurrency control.
+     *
+     * @param queueFn - Function that selects the API endpoint
+     * @param queueOptions - Optional configuration including `concurrency`
+     * @returns Object containing `trigger`, `queue`, `progress`, `abort`, `retry`, `remove`, `clear`
+     *
+     * @example
+     * ```tsx
+     * const { trigger, queue, progress } = useQueue(
+     *   (api) => api("uploads").POST(),
+     *   { concurrency: 2 }
+     * );
+     *
+     * for (const file of files) {
+     *   trigger({ body: form({ file }) });
+     * }
+     * ```
+     */
+    useQueue: UseQueueFn<TDefaultError, TSchema, TPlugins>;
 } & MergePluginInstanceApi<TPlugins, TSchema>;
 /**
  * Shape of a Spoosh instance required for creating React hooks.
@@ -412,18 +500,18 @@ type SpooshInstanceShape<TApi, TSchema, TDefaultError, TPlugins> = {
 };
 
 /**
- * Creates React hooks (useRead, useWrite, useInfiniteRead) from a Spoosh instance.
+ * Creates React hooks (useRead, useWrite, usePages) from a Spoosh instance.
  *
  * @template TSchema - The API schema type
  * @template TDefaultError - The default error type
  * @template TPlugins - The plugins array type
  * @template TApi - The API type
  * @param instance - The Spoosh instance containing api, stateManager, eventEmitter, and pluginExecutor
- * @returns An object containing useRead, useWrite, useInfiniteRead hooks and plugin instance APIs
+ * @returns An object containing useRead, useWrite, usePages hooks and plugin instance APIs
  *
  * @example
  * ```ts
- * const { useRead, useWrite, useInfiniteRead } = create(spooshInstance);
+ * const { useRead, useWrite, usePages } = create(spooshInstance);
  *
  * function MyComponent() {
  *   const { data, loading } = useRead((api) => api("posts").GET());
@@ -439,4 +527,4 @@ type PluginHooksConfig<TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[
     plugins: TPlugins;
 };
 
-export { type AnyInfiniteRequestOptions, type BaseInfiniteReadOptions, type BaseInfiniteReadResult, type BaseReadOptions, type BaseReadResult, type BaseWriteResult, type ExtractCoreMethodOptions, type ExtractMethodBody, type ExtractMethodData, type ExtractMethodError, type ExtractMethodOptions, type ExtractMethodQuery, type ExtractResponseBody, type ExtractResponseParamNames, type ExtractResponseQuery, type ExtractResponseRequestOptions, type InfiniteNextContext, type InfinitePrevContext, type InfiniteReadApiClient, type PluginHooksConfig, type ReadApiClient, type ResponseInputFields, type SpooshReactHooks, type TriggerOptions, type UseInfiniteReadResult, type UseReadResult, type UseWriteResult, type WriteApiClient, type WriteResponseInputFields, create };
+export { type BasePagesOptions, type BasePagesResult, type BaseReadOptions, type BaseReadResult, type BaseWriteResult, type ExtractCoreMethodOptions, type ExtractMethodBody, type ExtractMethodData, type ExtractMethodError, type ExtractMethodOptions, type ExtractMethodQuery, type ExtractResponseBody, type ExtractResponseParamNames, type ExtractResponseQuery, type ExtractResponseRequestOptions, type PagesApiClient, type PagesTriggerOptions, type PluginHooksConfig, type QueueApiClient, type QueueTriggerInput, type ReadApiClient, type ResponseInputFields, type SpooshReactHooks, type TriggerOptions, type UsePagesResult, type UseQueueOptions, type UseQueueResult, type UseReadResult, type UseWriteResult, type WriteApiClient, type WriteResponseInputFields, create };