@intrig/react 0.0.1 → 1.0.6

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@intrig/react",
-  "version": "0.0.1",
+  "version": "1.0.6",
   "main": "./index.js",
   "types": "./index.d.ts",
   "private": false,
   "exports": {
     ".": {
-      "import": "./index.mjs",
-      "require": "./index.js"
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    },
+    "./*": {
+      "import": "./src/*.js",
+      "types": "./src/*.d.ts"
     }
   },
   "dependencies": {

package/src/extra/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useResolvedValue';
+export * from './useResolvedCachedValue';
+export * from './useAsPromise';
+export * from './useAsNetworkState';

package/src/extra/useAsNetworkState.d.ts

@@ -0,0 +1,13 @@
+import { NetworkState } from '@intrig/react/network-state';
+/**
+ * A custom hook that integrates a promise-based operation with a network state management system.
+ * Tracks the network state (e.g., pending, success, error) for a given asynchronous function.
+ *
+ * @param fn A promise-based function that performs an asynchronous operation.
+ * @param key An optional string key to identify the network state uniquely. Defaults to 'default'.
+ * @return A tuple containing:
+ *         1. The current network state of the operation.
+ *         2. A function to execute the provided asynchronous operation.
+ *         3. A function to reset the network state back to the initial state.
+ */
+export declare function useAsNetworkState<T, F extends ((...args: any) => Promise<T>)>(fn: F, key?: string): [NetworkState<T>, (...params: Parameters<F>) => void, () => void];

package/src/extra/useAsPromise.d.ts

@@ -0,0 +1,59 @@
+import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook, UnaryFunctionHook, UnaryHookOptions, UnaryProduceHook, UnitHook, UnitHookOptions } from '@intrig/react/network-state';
+/**
+ * Transforms a unit hook into a promise, enabling asynchronous usage of the hook's lifecycle or events.
+ *
+ * @param {UnitHook<E>} hook - The unit hook to be used as a promise.
+ * @param {UnitHookOptions} options - Configuration options for the unit hook.
+ * @return {[() => Promise<never>, () => void]} A tuple containing a function that returns a promise resolving with the hook's completion
+ * result or rejecting with an error, and a function to clean up the hook's resources when no longer needed.
+ */
+export declare function useAsPromise<E>(hook: UnitHook<E>, options: UnitHookOptions): [() => Promise<never>, () => void];
+/**
+ * Converts a constant hook into a promise-based interface that can be invoked and reset.
+ *
+ * @param {ConstantHook<T, E>} hook - The constant hook to be converted.
+ * @param {UnitHookOptions} options - Configuration options for the hook behavior.
+ * @return {[() => Promise<T>, () => void]} A tuple where the first element is a function that returns a promise resolving with the hook value, and the second element is a reset function.
+ */
+export declare function useAsPromise<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): [() => Promise<T>, () => void];
+/**
+ * Wraps the provided hook function to return a promise-based API, offering more flexibility
+ * in asynchronous operations. This utility converts the hook into a callable function that
+ * returns a `Promise` and provides a way to clean up resources.
+ *
+ * @param {UnaryProduceHook<P, E>} hook - The hook function to be wrapped into a promise-based API.
+ * @param {UnaryHookOptions<P>} [options] - Optional parameters to configure the behavior of the hook.
+ * @return {[function(P): Promise<never>, function(): void]} Returns a tuple where the first element
+ * is a function that takes the hook's parameters and returns a `Promise`, and the second element
+ * is a cleanup function for resource management.
+ */
+export declare function useAsPromise<P, E>(hook: UnaryProduceHook<P, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<never>, () => void];
+/**
+ * Allows the usage of a hook's asynchronous behavior as a Promise.
+ *
+ * @param {UnaryFunctionHook<P, T, E>} hook - The hook function to be used as a Promise.
+ * @param {UnaryHookOptions<P>} [options] - Optional configuration object for the hook.
+ * @return {[function(P): Promise<T>, function(): void]} A tuple containing:
+ *     - A function that accepts parameters and returns a Promise resolving to the hook's result.
+ *     - A cleanup function to properly dispose of the hook when no longer needed.
+ */
+export declare function useAsPromise<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<T>, () => void];
+/**
+ * Converts a binary hook into a promise-based function, allowing the hook to be used asynchronously.
+ *
+ * @template P The type of the parameters for the hook.
+ * @template B The type of the body for the hook.
+ * @template E The type of the error handled by the hook.
+ * @param {BinaryProduceHook<P, B, E>} hook The binary hook to be converted into a promise-based function.
+ * @param {BinaryHookOptions<P, B>} [options] Optional configuration for the binary hook.
+ * @return {[(body: B, params: P) => Promise<never>, () => void]} A tuple where the first element is a function that returns a promise and the second is a cleanup function.
+ */
+export declare function useAsPromise<P, B, E>(hook: BinaryProduceHook<P, B, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<never>, () => void];
+/**
+ * Wraps a binary function hook into a promise-based interface.
+ *
+ * @param {BinaryFunctionHook<P, B, T, E>} hook The binary function hook to be wrapped.
+ * @param {BinaryHookOptions<P, B>} [options] Optional configuration options for the hook.
+ * @return {[function(B, P): Promise<T>, function(): void]} Returns a tuple containing a function that invokes the hook and returns a promise, and a cleanup function to dispose of the hook's resources.
+ */
+export declare function useAsPromise<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<T>, () => void];

package/src/extra/useResolvedCachedValue.d.ts

@@ -0,0 +1,54 @@
+import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook, UnaryFunctionHook, UnaryHookOptions, UnaryProduceHook, UnitHook, UnitHookOptions } from '@intrig/react/network-state';
+/**
+ * Resolves and caches the computed value of a given hook.
+ *
+ * @param {UnitHook<E>} hook - The hook to be resolved and cached. Represents a unit of work or computation.
+ * @param {UnitHookOptions} options - Options to customize the behavior of the hook resolution and caching process.
+ * @return {undefined} This function does not return a value.
+ */
+export declare function useResolvedCachedValue<E>(hook: UnitHook<E>, options: UnitHookOptions): undefined;
+/**
+ * Resolves and retrieves a cached value by utilizing a specified hook and options.
+ *
+ * @param {ConstantHook<T, E>} hook - The hook function used to compute or retrieve the cached value.
+ * @param {UnitHookOptions} options - Options controlling the behavior or configuration of the hook.
+ * @return {T | undefined} The resolved cached value or undefined if the value couldn't be determined.
+ */
+export declare function useResolvedCachedValue<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): T | undefined;
+/**
+ * Resolves and caches the value produced by the specified hook.
+ * This utility helps in managing hook-driven computational results within a component context by caching
+ * and avoiding unnecessary recalculations when the inputs remain the same.
+ *
+ * @param {UnaryProduceHook<P, E>} hook - The hook function to execute, responsible for producing a resolved value.
+ * @param {UnaryHookOptions<P>} options - The configuration options that control how the hook is executed.
+ * @return {undefined} Returns undefined since the resolution and caching of the value are managed internally.
+ */
+export declare function useResolvedCachedValue<P, E>(hook: UnaryProduceHook<P, E>, options: UnaryHookOptions<P>): undefined;
+/**
+ * Resolves a cached value using the provided hook and options.
+ *
+ * @param {UnaryFunctionHook<P, T, E>} hook - A hook function that accepts parameters of type P,
+ *                                           processes them, and returns a value of type T or possibly throws an error of type E.
+ * @param {UnaryHookOptions<P>} options - Configuration settings or arguments required by the hook to retrieve the cached value.
+ * @return {T | undefined} A value of type T if resolved successfully, or undefined if not available.
+ */
+export declare function useResolvedCachedValue<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options: UnaryHookOptions<P>): T | undefined;
+/**
+ * Resolves and caches the value produced by the provided binary hook function.
+ * This function ensures that the hook's resolved value is reused efficiently across invocations
+ * based on the provided options.
+ *
+ * @param {BinaryProduceHook<P, B, E>} hook - A hook function that produces the binary value to be resolved and cached.
+ * @param {BinaryHookOptions<P, B>} options - Configuration options for controlling the behavior of the hook and its caching mechanism.
+ * @return {undefined} - Returns undefined as the resolution is managed internally via the hook's lifecycle.
+ */
+export declare function useResolvedCachedValue<P, B, E>(hook: BinaryProduceHook<P, B, E>, options: BinaryHookOptions<P, B>): undefined;
+/**
+ * A hook utility function that resolves and caches a value based on the given binary function hook and options.
+ *
+ * @param {BinaryFunctionHook<P, B, T, E>} hook - The binary function hook used to compute the value.
+ * @param {BinaryHookOptions<P, B>} options - The options object containing parameters and configuration for the hook.
+ * @return {T | undefined} The resolved and cached value, or undefined if it cannot be resolved.
+ */
+export declare function useResolvedCachedValue<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options: BinaryHookOptions<P, B>): T | undefined;

package/src/extra/useResolvedValue.d.ts

@@ -0,0 +1,50 @@
+import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook, UnaryFunctionHook, UnaryHookOptions, UnaryProduceHook, UnitHook, UnitHookOptions } from '@intrig/react/network-state';
+/**
+ * A function that resolves the value provided by a unit hook based on specified options.
+ *
+ * @param {UnitHook<E>} hook - The unit hook function that provides the value to be resolved.
+ * @param {UnitHookOptions} options - Configuration options to control how the unit hook is resolved.
+ * @return {undefined} Returns undefined after resolving the unit hook value.
+ */
+export declare function useResolvedValue<E>(hook: UnitHook<E>, options: UnitHookOptions): undefined;
+/**
+ * Resolves the value of a given constant hook based on the provided options.
+ *
+ * @param {ConstantHook<T, E>} hook - The constant hook to be resolved.
+ * @param {UnitHookOptions} options - The options used to configure the resolution of the hook value.
+ * @return {T | undefined} The resolved value of the hook or undefined if the hook cannot be resolved.
+ */
+export declare function useResolvedValue<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): T | undefined;
+/**
+ * This function is a utility hook that evaluates and resolves the value of the provided hook function.
+ * It takes a hook function and its corresponding options as arguments to produce side effects or state updates.
+ *
+ * @param {UnaryProduceHook<P, E>} hook - A hook function that is responsible for creating or updating a state or effect.
+ * @param {UnaryHookOptions<P>} options - Configuration options for the hook, such as parameters or behaviors.
+ * @return {undefined} This function does not return a value; it operates through side effects or resolves implicitly.
+ */
+export declare function useResolvedValue<P, E>(hook: UnaryProduceHook<P, E>, options: UnaryHookOptions<P>): undefined;
+/**
+ * A custom hook that provides a resolved value based on the provided unary function hook and options.
+ *
+ * @param {UnaryFunctionHook<P, T, E>} hook - The primary unary function hook that processes the input and resolves a value.
+ * @param {UnaryHookOptions<P>} options - The configuration object containing parameters for the unary hook execution.
+ * @return {T | undefined} The resolved value of type T if successful, or undefined if no value is resolved.
+ */
+export declare function useResolvedValue<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options: UnaryHookOptions<P>): T | undefined;
+/**
+ * A custom hook that processes a binary produce hook and its options to produce a resolved value.
+ *
+ * @param {BinaryProduceHook<P, B, E>} hook - The binary produce hook to be resolved.
+ * @param {BinaryHookOptions<P, B>} options - The options provided to the binary hook for processing.
+ * @return {undefined} Returns `undefined` after the hook is resolved.
+ */
+export declare function useResolvedValue<P, B, E>(hook: BinaryProduceHook<P, B, E>, options: BinaryHookOptions<P, B>): undefined;
+/**
+ * Resolves a value based on the provided binary function hook and options.
+ *
+ * @param {BinaryFunctionHook<P, B, T, E>} hook - The binary function hook that defines the logic to resolve the value.
+ * @param {BinaryHookOptions<P, B>} options - Configuration options for the binary function hook.
+ * @return {T | undefined} The resolved value of type T, or undefined if the resolution fails.
+ */
+export declare function useResolvedValue<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options: BinaryHookOptions<P, B>): T | undefined;

package/src/index.d.ts

@@ -1,2 +1,4 @@
 export * from './intrig-provider';
 export * from './network-state';
+export * from './extra/index';
+export * from './media-type-utils';

package/src/intrig-context.d.ts

@@ -28,9 +28,9 @@ interface RequestType<T = any> {
 export interface ContextType {
     state: GlobalState;
     filteredState: GlobalState;
-    dispatch: React.Dispatch<NetworkAction<unknown>>;
+    dispatch: React.Dispatch<NetworkAction<unknown, unknown>>;
     configs: DefaultConfigs;
-    execute: <T>(request: RequestType, dispatch: (state: NetworkState<T>) => void, schema: ZodSchema<T> | undefined) => Promise<void>;
+    execute: <T, E = unknown>(request: RequestType, dispatch: (state: NetworkState<T, E>) => void, schema: ZodSchema<T> | undefined, errorSchema: ZodSchema<E> | undefined) => Promise<void>;
 }
 /**
  * Context object created using `createContext` function. Provides a way to share state, dispatch functions,

package/src/intrig-provider.d.ts

@@ -48,11 +48,12 @@ export interface StatusTrapProps {
  * @return {React.ReactElement} The context provider component with filtered state and custom dispatch.
  */
 export declare function StatusTrap({ children, type, propagate, }: PropsWithChildren<StatusTrapProps>): import("react/jsx-runtime").JSX.Element;
-export interface NetworkStateProps<T> {
+export interface NetworkStateProps<T, E = unknown> {
     key: string;
     operation: string;
     source: string;
     schema?: ZodSchema<T>;
+    errorSchema?: ZodSchema<E>;
     debounceDelay?: number;
 }
 /**
@@ -71,23 +72,23 @@ export interface NetworkStateProps<T> {
  *          Returns a state object representing the current network state,
  *          a function to execute the network request, and a function to clear the request.
  */
-export declare function useNetworkState<T>({ key, operation, source, schema, debounceDelay: requestDebounceDelay, }: NetworkStateProps<T>): [
-    NetworkState<T>,
+export declare function useNetworkState<T, E = unknown>({ key, operation, source, schema, errorSchema, debounceDelay: requestDebounceDelay, }: NetworkStateProps<T>): [
+    NetworkState<T, E>,
     (request: RequestType) => void,
     clear: () => void,
-    (state: NetworkState<T>) => void
+    (state: NetworkState<T, E>) => void
 ];
 /**
  * Handles central error extraction from the provided context.
  * It filters the state to retain error states and maps them to a structured error object with additional context information.
  * @return {Object[]} An array of objects representing the error states with context information such as source, operation, and key.
  */
-export declare function useCentralErrorHandling(): {
+export declare function useCentralError(): {
     source: string;
     operation: string;
     key: string;
     state: "error";
-    error: any;
+    error: unknown;
     statusCode?: number;
     request?: any;
 }[];
@@ -97,4 +98,4 @@ export declare function useCentralErrorHandling(): {
  *
  * @return {NetworkState} The aggregated network state based on the pending states and their progress.
  */
-export declare function useCentralPendingStateHandling(): NetworkState<unknown>;
+export declare function useCentralPendingState(): NetworkState<unknown, unknown>;

package/src/media-type-utils.d.ts

@@ -0,0 +1,3 @@
+import { ZodSchema } from 'zod';
+export declare function transform<T>(request: Request, mediaType: string, schema: ZodSchema): Promise<T>;
+export declare function transformResponse<T>(data: any, mediaType: string, schema: ZodSchema): Promise<T>;

package/src/network-state.d.ts

@@ -1,3 +1,4 @@
+import { ZodError } from 'zod';
 /**
  * State of an asynchronous call. Network state follows the state diagram given below.
  *
@@ -21,31 +22,31 @@
  *
  * </pre>
  */
-export interface NetworkState<T = unknown> {
+export interface NetworkState<T = unknown, E = unknown> {
     state: 'init' | 'pending' | 'success' | 'error';
 }
 /**
  * Network call is not yet started
  */
-export interface InitState<T> extends NetworkState<T> {
+export interface InitState<T, E = unknown> extends NetworkState<T, E> {
     state: 'init';
 }
 /**
  * Checks whether the state is init state
  * @param state
  */
-export declare function isInit<T>(state: NetworkState<T>): state is InitState<T>;
+export declare function isInit<T, E = unknown>(state: NetworkState<T, E>): state is InitState<T, E>;
 /**
  * Initializes a new state.
  *
  * @template T The type of the state.
  * @return {InitState<T>} An object representing the initial state.
  */
-export declare function init<T>(): InitState<T>;
+export declare function init<T, E = unknown>(): InitState<T, E>;
 /**
  * Network call is not yet completed
  */
-export interface PendingState<T> extends NetworkState<T> {
+export interface PendingState<T, E = unknown> extends NetworkState<T, E> {
     state: 'pending';
     progress?: Progress;
 }
@@ -69,17 +70,17 @@ export interface Progress {
  * Checks whether the state is pending state
  * @param state
  */
-export declare function isPending<T>(state: NetworkState<T>): state is PendingState<T>;
+export declare function isPending<T, E = unknown>(state: NetworkState<T, E>): state is PendingState<T, E>;
 /**
  * Generates a PendingState object with a state of "pending".
  *
  * @return {PendingState<T>} An object representing the pending state.
  */
-export declare function pending<T>(progress?: Progress | undefined): PendingState<T>;
+export declare function pending<T, E = unknown>(progress?: Progress | undefined): PendingState<T, E>;
 /**
  * Network call is completed with success state
  */
-export interface SuccessState<T> extends NetworkState<T> {
+export interface SuccessState<T, E = unknown> extends NetworkState<T, E> {
     state: 'success';
     data: T;
 }
@@ -87,20 +88,20 @@ export interface SuccessState<T> extends NetworkState<T> {
  * Checks whether the state is success response
  * @param state
  */
-export declare function isSuccess<T>(state: NetworkState<T>): state is SuccessState<T>;
+export declare function isSuccess<T, E = unknown>(state: NetworkState<T, E>): state is SuccessState<T, E>;
 /**
  * Creates a success state object with the provided data.
  *
  * @param {T} data - The data to be included in the success state.
  * @return {SuccessState<T>} An object representing a success state containing the provided data.
  */
-export declare function success<T>(data: T): SuccessState<T>;
+export declare function success<T, E = unknown>(data: T): SuccessState<T, E>;
 /**
  * Network call is completed with error response
  */
-export interface ErrorState<T> extends NetworkState<T> {
+export interface ErrorState<T, E = unknown> extends NetworkState<T, E> {
     state: 'error';
-    error: any;
+    error: E;
     statusCode?: number;
     request?: any;
 }
@@ -108,7 +109,7 @@ export interface ErrorState<T> extends NetworkState<T> {
  * Checks whether the state is error state
  * @param state
  */
-export declare function isError<T>(state: NetworkState<T>): state is ErrorState<T>;
+export declare function isError<T, E = unknown>(state: NetworkState<T, E>): state is ErrorState<T, E>;
 /**
  * Constructs an ErrorState object representing an error.
  *
@@ -116,7 +117,7 @@ export declare function isError<T>(state: NetworkState<T>): state is ErrorState<
  * @param {string} [statusCode] - An optional status code associated with the error.
  * @return {ErrorState<T>} An object representing the error state.
  */
-export declare function error<T>(error: any, statusCode?: number, request?: any): ErrorState<T>;
+export declare function error<T, E = unknown>(error: E, statusCode?: number, request?: any): ErrorState<T>;
 /**
  * Represents an error state with additional contextual information.
  *
@@ -128,7 +129,7 @@ export declare function error<T>(error: any, statusCode?: number, request?: any)
  * @property {string} operation - The operation being performed when the error occurred.
  * @property {string} key - A unique key identifying the specific error instance.
  */
-export interface ErrorWithContext<T = unknown> extends ErrorState<T> {
+export interface ErrorWithContext<T = unknown, E = unknown> extends ErrorState<T, E> {
     source: string;
     operation: string;
     key: string;
@@ -141,25 +142,55 @@ export interface ErrorWithContext<T = unknown> extends ErrorState<T> {
  * @property {NetworkState<any>} state - The current state of the network action
  * @property {string} key - The unique identifier for the network action
  */
-export interface NetworkAction<T> {
+export interface NetworkAction<T, E> {
     key: string;
     source: string;
     operation: string;
-    state: NetworkState<T>;
+    state: NetworkState<T, E>;
     handled?: boolean;
 }
 type HookWithKey = {
     key: string;
 };
-export type DeleteHook<P> = ((key?: string) => [NetworkState<never>, (params: P) => void, () => void]) & HookWithKey;
-export type DeleteHookOp<P> = ((key?: string) => [NetworkState<never>, (params?: P) => void, () => void]) & HookWithKey;
-export type GetHook<P, T> = ((key?: string) => [NetworkState<T>, (params: P) => void, () => void]) & HookWithKey;
-export type GetHookOp<P, T> = ((key?: string) => [NetworkState<T>, (params?: P) => void, () => void]) & HookWithKey;
-export type PostHook<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params: P) => void, () => void]) & HookWithKey;
-export type PostHookOp<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params?: P) => void, () => void]) & HookWithKey;
-export type PutHook<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params: P) => void, () => void]) & HookWithKey;
-export type PutHookOp<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params?: P) => void, () => void]) & HookWithKey;
-export type IntrigHook<P = undefined, B = undefined, T = any> = DeleteHook<P> | GetHook<P, T> | PostHook<P, T, B> | PutHook<P, T, B> | PostHookOp<P, T, B> | PutHookOp<P, T, B> | GetHookOp<P, T> | DeleteHookOp<P>;
+export type UnitHookOptions = {
+    key?: string;
+    fetchOnMount?: false;
+    clearOnUnmount?: boolean;
+} | {
+    key?: string;
+    fetchOnMount: true;
+    params?: Record<string, any>;
+    clearOnUnmount?: boolean;
+};
+export type UnitHook<E = unknown> = ((options: UnitHookOptions) => [NetworkState<never, E>, (params?: Record<string, any>) => DispatchState<any>, () => void]) & HookWithKey;
+export type ConstantHook<T, E = unknown> = ((options: UnitHookOptions) => [NetworkState<T, E>, (params?: Record<string, any>) => DispatchState<any>, () => void]) & HookWithKey;
+export type UnaryHookOptions<P> = {
+    key?: string;
+    fetchOnMount?: false;
+    clearOnUnmount?: boolean;
+} | {
+    key?: string;
+    fetchOnMount: true;
+    params: P;
+    clearOnUnmount?: boolean;
+};
+export type UnaryProduceHook<P, E = unknown> = ((options?: UnaryHookOptions<P>) => [NetworkState<never, E>, (params: P) => DispatchState<any>, () => void]) & HookWithKey;
+export type UnaryFunctionHook<P, T, E = unknown> = ((options?: UnaryHookOptions<P>) => [NetworkState<T, E>, (params: P) => DispatchState<any>, () => void]) & HookWithKey;
+export type BinaryHookOptions<P, B> = {
+    key?: string;
+    fetchOnMount?: false;
+    clearOnUnmount?: boolean;
+} | {
+    key?: string;
+    fetchOnMount: true;
+    params: P;
+    body: B;
+    clearOnUnmount?: boolean;
+};
+export type BinaryProduceHook<P, B, E = unknown> = ((options?: BinaryHookOptions<P, B>) => [NetworkState<never, E>, (body: B, params: P) => DispatchState<any>, () => void]) & HookWithKey;
+export type BinaryFunctionHook<P, B, T, E = unknown> = ((options?: BinaryHookOptions<P, B>) => [NetworkState<T, E>, (body: B, params: P) => DispatchState<any>, () => void]) & HookWithKey;
+export type IntrigHookOptions<P = undefined, B = undefined> = UnitHookOptions | UnaryHookOptions<P> | BinaryHookOptions<P, B>;
+export type IntrigHook<P = undefined, B = undefined, T = any, E = unknown> = UnitHook<E> | ConstantHook<T, E> | UnaryProduceHook<P, E> | UnaryFunctionHook<P, T, E> | BinaryProduceHook<P, B, E> | BinaryFunctionHook<P, B, T, E>;
 /**
  * Represents the dispatch state of a process.
  *
@@ -220,4 +251,111 @@ export declare function validationError<T>(error: any): ValidationError<T>;
  * @return {boolean} - Returns true if the provided DispatchState object is a ValidationError, otherwise returns false.
  */
 export declare function isValidationError<T>(value: DispatchState<T>): value is ValidationError<T>;
+/**
+ * Represents an error structure with a specified type and associated data.
+ *
+ * @template T - The type of the data associated with the error.
+ * @template E - The type of the error detail.
+ *
+ * @property {string} type - A string representing the type of the error.
+ */
+export interface IntrigError<T, E> {
+    type: string;
+}
+/**
+ * Represents an error encountered during a network operation.
+ * Extends from the `IntrigError` interface, adding network-specific properties.
+ *
+ * @template T - The type of the intrinsic data associated with the error.
+ * @template E - The type of the error details, defaulting to `unknown`.
+ *
+ * @property {string} type - A constant property representing the error type, always set to 'network'.
+ * @property {string} statusCode - A string representation of the HTTP status code associated with the error, indicating the nature of the network failure.
+ * @property {E} error - The detailed error information specific to the failure, type extends from the generic E, allowing flexibility in the error details.
+ * @property {any} request - The request object that was attempted when the network error occurred, providing context for what operation failed.
+ */
+export interface NetworkError<T, E = unknown> extends IntrigError<T, E> {
+    type: 'network';
+    statusCode: string;
+    error: E;
+    request: any;
+}
+/**
+ * Constructs a network error object.
+ *
+ * @param error The error object corresponding to the network request.
+ * @param statusCode A string representing the HTTP status code returned.
+ * @param request The request object associated with the network operation.
+ * @return A NetworkError object containing the error type, status code, error details, and the original request.
+ */
+export declare function networkError<T, E>(error: E, statusCode: string, request: any): NetworkError<T, E>;
+/**
+ * Determines if the provided IntrigError is of type 'network'.
+ *
+ * @param {IntrigError<T, E>} value - The error value to check the type of.
+ * @return {boolean} - Returns true if the error is of type 'network', otherwise false.
+ */
+export declare function isNetworkError<T, E>(value: IntrigError<T, E>): value is NetworkError<T, E>;
+/**
+ * Interface representing a request validation error.
+ *
+ * This error occurs when a validation process on a request fails. It extends the IntrigError interface
+ * by adding specific properties related to request validation.
+ *
+ * @template T - The type of the data associated with the error.
+ * @template E - The optional type of additional error information. Defaults to unknown.
+ *
+ * @extends IntrigError<T, E>
+ *
+ * @property {string} type - A string literal indicating the error type as 'request-validation'.
+ * @property {ZodError} error - An instance of ZodError containing detailed validation error information.
+ */
+export interface RequestValidationError<T, E = unknown> extends IntrigError<T, E> {
+    type: 'request-validation';
+    error: ZodError;
+}
+/**
+ * Constructs a RequestValidationError object encapsulating the ZodError.
+ *
+ * @param {ZodError} error - The error object resulting from Zod schema validation.
+ * @return {RequestValidationError<T, E>} A RequestValidationError object containing the validation error information.
+ */
+export declare function requestValidationError<T, E>(error: ZodError): RequestValidationError<T, E>;
+/**
+ * Determines if a given error is of type RequestValidationError.
+ *
+ * @param value The error object to check, which implements the IntrigError interface.
+ * @return A boolean indicating whether the error is a RequestValidationError.
+ */
+export declare function isRequestValidationError<T, E>(value: IntrigError<T, E>): value is RequestValidationError<T, E>;
+/**
+ * ResponseValidationError interface is designed to extend the capabilities of the IntrigError interface,
+ * specifically for handling errors related to response validation.
+ *
+ * @template T - Represents the type of the data or payload associated with the error.
+ * @template E - Represents the type of any additional error information. Defaults to unknown.
+ *
+ * @extends IntrigError
+ *
+ * @property type - A string literal that identifies the type of error as 'response-validation'.
+ * @property error - An instance of ZodError representing the validation error encountered.
+ */
+export interface ResponseValidationError<T, E = unknown> extends IntrigError<T, E> {
+    type: 'response-validation';
+    error: ZodError;
+}
+/**
+ * Constructs a ResponseValidationError object with a specified error.
+ *
+ * @param {ZodError} error - The validation error encountered during response validation.
+ * @return {ResponseValidationError<T, E>} An error object containing the type of error and the validation error details.
+ */
+export declare function responseValidationError<T, E>(error: ZodError): ResponseValidationError<T, E>;
+/**
+ * Determines if the given error is a response validation error.
+ *
+ * @param {IntrigError<T, E>} value - The error object to assess.
+ * @return {boolean} True if the error is a response validation error, otherwise false.
+ */
+export declare function isResponseValidationError<T, E>(value: IntrigError<T, E>): value is ResponseValidationError<T, E>;
 export {};