@intrig/react 0.0.1 → 1.0.2

package/README.md

@@ -1,82 +1,33 @@
 # Intrig
 
-<a alt="Nx logo" href="https://nx.dev" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-logo.png" width="45"></a>
+Intrig is a powerful tool for simplifying API integration in React applications. It provides enhanced documentation, API version management, and developer tooling for seamless frontend-backend integration.
 
-✨ Your new, shiny [Nx workspace](https://nx.dev) is almost ready ✨.
+## Getting Started
 
-[Learn more about this workspace setup and its capabilities](https://nx.dev/nx-api/node?utm_source=nx_project&amp;utm_medium=readme&amp;utm_campaign=nx_projects) or run `npx nx graph` to visually explore what was created. Now, let's get you up to speed!
+Prerequisites
 
-## Finish your CI setup
+* Node.js v16+.
+* Nx build tool.
 
-[Click here to finish setting up your workspace!](https://cloud.nx.app/connect/e4mOmAhulO)
+## Installation
 
+Clone the repository and install dependencies:
 
-## Run tasks
+```bash
+$ git clone https://github.com/your-username/intrig.git
+$ cd intrig
+$ npm install
 
-To run the dev server for your app, use:
-
-```sh
-npx nx serve intrig
-```
-
-To create a production bundle:
-
-```sh
-npx nx build intrig
-```
-
-To see all available targets to run for a project, run:
-
-```sh
-npx nx show project intrig
 ```
 
-These targets are either [inferred automatically](https://nx.dev/concepts/inferred-tasks?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects) or defined in the `project.json` or `package.json` files.
-
-[More about running tasks in the docs &raquo;](https://nx.dev/features/run-tasks?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
-
-## Add new projects
-
-While you could add new projects to your workspace manually, you might want to leverage [Nx plugins](https://nx.dev/concepts/nx-plugins?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects) and their [code generation](https://nx.dev/features/generate-code?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects) feature.
-
-Use the plugin's generator to create new projects.
-
-To generate a new application, use:
-
-```sh
-npx nx g @nx/node:app demo
-```
-
-To generate a new library, use:
-
-```sh
-npx nx g @nx/node:lib mylib
-```
-
-You can use `npx nx list` to get a list of installed plugins. Then, run `npx nx list <plugin-name>` to learn about more specific capabilities of a particular plugin. Alternatively, [install Nx Console](https://nx.dev/getting-started/editor-setup?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects) to browse plugins and generators in your IDE.
-
-[Learn more about Nx plugins &raquo;](https://nx.dev/concepts/nx-plugins?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects) | [Browse the plugin registry &raquo;](https://nx.dev/plugin-registry?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
-
-
-[Learn more about Nx on CI](https://nx.dev/ci/intro/ci-with-nx#ready-get-started-with-your-provider?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
-
-## Install Nx Console
-
-Nx Console is an editor extension that enriches your developer experience. It lets you run tasks, generate code, and improves code autocompletion in your IDE. It is available for VSCode and IntelliJ.
+## License
 
-[Install Nx Console &raquo;](https://nx.dev/getting-started/editor-setup?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
+Intrig is open source software licensed under the [MIT License](LICENSE).
 
-## Useful links
+## Contribution
 
-Learn more:
+We welcome contributions! Please read our [contributing guide](CONTRIBUTING.md) to learn how you can get involved.
 
-- [Learn more about this workspace setup](https://nx.dev/nx-api/node?utm_source=nx_project&amp;utm_medium=readme&amp;utm_campaign=nx_projects)
-- [Learn about Nx on CI](https://nx.dev/ci/intro/ci-with-nx?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
-- [Releasing Packages with Nx release](https://nx.dev/features/manage-releases?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
-- [What are Nx plugins?](https://nx.dev/concepts/nx-plugins?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
+## Contact
 
-And join the Nx community:
-- [Discord](https://go.nx.dev/community)
-- [Follow us on X](https://twitter.com/nxdevtools) or [LinkedIn](https://www.linkedin.com/company/nrwl)
-- [Our Youtube channel](https://www.youtube.com/@nxdevtools)
-- [Our blog](https://nx.dev/blog?utm_source=nx_project&utm_medium=readme&utm_campaign=nx_projects)
+For questions or feedback, feel free to reach out at [support@intrigsoft.com](mailto\:support@intrigsoft.com).

package/index.esm.js

@@ -3093,6 +3093,73 @@ function validationError(error) {
 function isValidationError(value) {
   return value.state === 'validation-error';
 }
+/**
+ * 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.
+ */
+function networkError(error, statusCode, request) {
+  return {
+    type: 'network',
+    statusCode,
+    error,
+    request
+  };
+}
+/**
+ * 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.
+ */
+function isNetworkError(value) {
+  return value.type === 'network';
+}
+/**
+ * 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.
+ */
+function requestValidationError(error) {
+  return {
+    type: 'request-validation',
+    error
+  };
+}
+/**
+ * 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.
+ */
+function isRequestValidationError(value) {
+  return value.type === 'request-validation';
+}
+/**
+ * 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.
+ */
+function responseValidationError(error) {
+  return {
+    type: 'response-validation',
+    error
+  };
+}
+/**
+ * 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.
+ */
+function isResponseValidationError(value) {
+  return value.type === 'response-validation';
+}
 
 /**
  * Context object created using `createContext` function. Provides a way to share state, dispatch functions,
@@ -3140,7 +3207,7 @@ function IntrigProvider({
     return {};
   }, [configs]);
   const contextValue = useMemo(() => {
-    async function execute(request, dispatch, schema) {
+    async function execute(request, dispatch, schema, errorSchema) {
       try {
         dispatch(pending());
         let response = await axiosInstances[request.source].request(request);
@@ -3156,13 +3223,22 @@ function IntrigProvider({
             dispatch(success(response.data));
           }
         } else {
-          var _response$data;
-          dispatch(error((_response$data = response.data) != null ? _response$data : response.statusText, response.status));
+          var _errorSchema$safePars, _response$data, _ref;
+          let {
+            data,
+            error: validationError
+          } = (_errorSchema$safePars = errorSchema == null ? void 0 : errorSchema.safeParse((_response$data = response.data) != null ? _response$data : {})) != null ? _errorSchema$safePars : {};
+          //todo: handle error validation error.
+          dispatch(error((_ref = data != null ? data : response.data) != null ? _ref : response.statusText, response.status));
         }
       } catch (e) {
         if (isAxiosError(e)) {
-          var _e$response, _e$response2;
-          dispatch(error((_e$response = e.response) == null ? void 0 : _e$response.data, (_e$response2 = e.response) == null ? void 0 : _e$response2.status, request));
+          var _errorSchema$safePars2, _e$response$data, _e$response, _e$response2, _e$response3;
+          let {
+            data,
+            error: validationError
+          } = (_errorSchema$safePars2 = errorSchema == null ? void 0 : errorSchema.safeParse((_e$response$data = (_e$response = e.response) == null ? void 0 : _e$response.data) != null ? _e$response$data : {})) != null ? _errorSchema$safePars2 : {};
+          dispatch(error(data != null ? data : (_e$response2 = e.response) == null ? void 0 : _e$response2.data, (_e$response3 = e.response) == null ? void 0 : _e$response3.status, request));
         } else {
           dispatch(error(e));
         }
@@ -3297,6 +3373,7 @@ function useNetworkState({
   operation,
   source,
   schema,
+  errorSchema,
   debounceDelay: requestDebounceDelay
 }) {
   var _context$state3;
@@ -3315,8 +3392,8 @@ function useNetworkState({
     });
   }, [key, operation, source, context.dispatch]);
   const debounceDelay = useMemo(() => {
-    var _ref, _context$configs;
-    return (_ref = requestDebounceDelay != null ? requestDebounceDelay : (_context$configs = context.configs) == null ? void 0 : _context$configs.debounceDelay) != null ? _ref : 0;
+    var _ref2, _context$configs;
+    return (_ref2 = requestDebounceDelay != null ? requestDebounceDelay : (_context$configs = context.configs) == null ? void 0 : _context$configs.debounceDelay) != null ? _ref2 : 0;
   }, [context.configs, requestDebounceDelay]);
   const execute = useCallback(async request => {
     let abortController = new AbortController();
@@ -3340,7 +3417,7 @@ function useNetworkState({
       },
       signal: abortController.signal
     });
-    await context.execute(requestConfig, dispatch, schema);
+    await context.execute(requestConfig, dispatch, schema, errorSchema);
   }, [networkState, context.dispatch, axios]);
   const deboundedExecute = useMemo(() => debounce(execute, debounceDelay != null ? debounceDelay : 0), [execute]);
   const clear = useCallback(() => {
@@ -3409,4 +3486,4 @@ function useCentralPendingStateHandling() {
   return result;
 }
 
-export { IntrigProvider, IntrigProviderStub, StatusTrap, error, init, isError, isInit, isPending, isSuccess, isSuccessfulDispatch, isValidationError, pending, success, successfulDispatch, useCentralErrorHandling, useCentralPendingStateHandling, useNetworkState, validationError };
+export { IntrigProvider, IntrigProviderStub, StatusTrap, error, init, isError, isInit, isNetworkError, isPending, isRequestValidationError, isResponseValidationError, isSuccess, isSuccessfulDispatch, isValidationError, networkError, pending, requestValidationError, responseValidationError, success, successfulDispatch, useCentralErrorHandling, useCentralPendingStateHandling, useNetworkState, validationError };

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@intrig/react",
-  "version": "0.0.1",
+  "version": "1.0.2",
   "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/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>(request: RequestType, dispatch: (state: NetworkState<T>) => void, schema: ZodSchema<T> | undefined, errorSchema: ZodSchema<T> | undefined) => Promise<void>;
 }
 /**
  * Context object created using `createContext` function. Provides a way to share state, dispatch functions,

package/src/intrig-provider.d.ts

@@ -53,6 +53,7 @@ export interface NetworkStateProps<T> {
     operation: string;
     source: string;
     schema?: ZodSchema<T>;
+    errorSchema?: ZodSchema<T>;
     debounceDelay?: number;
 }
 /**
@@ -71,11 +72,11 @@ 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.
@@ -87,7 +88,7 @@ export declare function useCentralErrorHandling(): {
     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 useCentralPendingStateHandling(): NetworkState<unknown, unknown>;

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,24 +142,24 @@ 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 DeleteHook<P, E = unknown> = ((key?: string) => [NetworkState<never, E>, (params: P) => void, () => void]) & HookWithKey;
+export type DeleteHookOp<P, E = unknown> = ((key?: string) => [NetworkState<never, E>, (params?: P) => void, () => void]) & HookWithKey;
+export type GetHook<P, T, E = unknown> = ((key?: string) => [NetworkState<T, E>, (params: P) => void, () => void]) & HookWithKey;
+export type GetHookOp<P, T, E = unknown> = ((key?: string) => [NetworkState<T, E>, (params?: P) => void, () => void]) & HookWithKey;
+export type PostHook<P, T, B, E = unknown> = ((key?: string) => [NetworkState<T, E>, (body: B, params: P) => void, () => void]) & HookWithKey;
+export type PostHookOp<P, T, B, E = unknown> = ((key?: string) => [NetworkState<T, E>, (body: B, params?: P) => void, () => void]) & HookWithKey;
+export type PutHook<P, T, B, E = unknown> = ((key?: string) => [NetworkState<T, E>, (body: B, params: P) => void, () => void]) & HookWithKey;
+export type PutHookOp<P, T, B, E = unknown> = ((key?: string) => [NetworkState<T, E>, (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>;
 /**
  * Represents the dispatch state of a process.
@@ -220,4 +221,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 {};